导入依赖：
1.父项目依赖配置：
org.springframework spring-framework-bom4.3.10.RELEASE pom import org.apache.maven.plugins maven-compiler-plugin1.8 1.8 UTF-8 org.apache.maven.plugins maven-surefire-plugintrue src/main/java ***.properties src/main/resources ***.properties
2.子项目依赖配置：
org.springframework spring-core4.3.10.RELEASE commons-logging commons-loggingorg.springframework spring-contextjunit junit4.12 org.slf4j slf4j-log4j121.7.21 org.slf4j jcl-over-slf4j1.7.21 org.projectlombok lombok1.18.20 org.springframework spring-testjavax.inject javax.inject1
Spring的核心：
- IOC （Inverse of control ）反转控制 或者DI (Dependency Injection，依赖注入）
- IOC不是什么技术，就是一种设计思想。以往我们需要什么对象就要自己new一个对象，IOC就是将原来new对象交给spring，由spring来创建对象，从spring工厂获得对象，而spring负责控制对象的生命周期和对象与对象之间的关系。
eg:就好比现在你遇到一个你喜欢的女生，你想要熟悉了解她，打探她的消息：喜欢啥东西，性格怎么样...还要花时间追。在找女朋友的过程自己要操作每一步。现在有个相亲网，在上面注册一个号，人后告诉红娘：嗯嗯。。我喜欢啥类型的女生，描述一下自己的需求。然后呢，找女朋友这件事就省事多了，红娘找到匹配的信息，然后就给你匹配到这些类型的女生，如果没有信息匹配，返回异常。整个过程不再由我自己控制，而是有相亲网这样一个类似容器的机构来控制。
Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。
2.DI (Dependency Injection，依赖注入）
理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”
●谁依赖于谁：当然是应用程序依赖于IoC容器；
●为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；
●谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；
●注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。
3.AOP （Aspect Oriented Programming）面向切面编程
1. spring IOC
第一步：写配置文件
beanConfig.xml
Bean的配置
Bean细节：
使用Bean 把某个类的对象交给spring, spring创建该类的对象, 默认调用无参构造方法,
如果某个类没有提供无参构造方法，抛如下错误：
bean的默认创建时机: spring容器创建之后马上创建对象，
@Data
public class Single {
private String name;
public Single() {
System.out.println("单例的无参构造");
}
public Single(String name) {
System.out.println("单例的有参构造");
this.name = name;
}
}
@Test
public void beanTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("beanConfig.xml");
Person p1 = (Person) context.getBean("p1");
Person p2 = (Person) context.getBean("p1");
System.out.println(p1==p2);
}
bean 对象默认是单例 bean标签对应的对象是唯一,不是该类只能创建一个对象,不是所谓单例模式
getBean(Class clazz) 根据类型获取bean对象, 前提条件: 该类型的bean在Spring容器只能有一个.
@Test
public void beanTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("beanConfig.xml");
Person p1 = (Person) context.getBean(Person.class);
Person p2 = (Person) context.getBean("p1");
System.out.println(p1==p2);
}
Person p1 = (Person) context.getBean(Person.class);
使用这个在配置文件中要只有一个Person
Bean的Scope:
常用的: singleton,默认值, Struts2 处理用户请求: Action Action 类对象一定设置为prototype
Servlet类一定不要写数据类型的属性
多例: bean的创建时机: 在调用getBean() 创建
Bean的属性注入方式: 集合、数组属性的注入 目的：与其他框架整合@Data
public class Person {
private Integer id;
private String name;
private Car car;
private Integer[] arr;
private List list;
private Set set;
private Map map;
private Properties pro;
}
1 2 3
l1 l2 l3 set1 set1 set2 pp ppp
beanConfig.xml 的运行：
dao接口
public interface UserDao {
void getUser();
void outUser(String name);
}
dao实现类：
public class UserdaoImpl implements UserDao {
public void getUser() {
System.out.println("获取用户默认数据");
}
public void outUser(String name) {
System.out.println("User名字:" + name);
}
}
public class UserDaoOricelImpl implements UserDao {
public void getUser() {
System.out.println("Oricel 获取用户数据");
}
public void outUser(String name) {
}
}
public class UserdaoRedisImpl implements UserDao {
public void getUser() {
System.out.println("Redis 获取用户数据");
}
public void outUser(String name) {
}
}
测试类编写：
@Test
public void userDaoTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("aplicationContext.xml");
UserService userService = (UserService) context.getBean("userService");
userService.getUser();
}
结果：
spring DI (Dependency Injection，依赖注入）
IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象--->简单理解就是我们在service层要调用dao层的方法，以往要自己手动在service层new dao层的对象，才能调用dao层大方法。现在有了spring，在service层你需要要用到dao层的方法，你只需要告诉spring我需要dao层的对象，自己不用 关心dao层对象是怎样创建的。在运行service层时，spring会在适当的时候制造一个dao对象。把dao对象注入到service层中，这样就完成了各个对象之间的关系控制。service层需要依赖dao才能正常运行，到就是由spring注入到service层中，依赖注入名字就是这样来的。那么DI是如何实现的呢？Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。
依赖注入测试：
基于注解：
dao：
public interface UserDao {
void addUser();
}
daoImp：
@Repository("userDao")
@Scope("prototype") //每次用户调用getBean(String name)时,产生一个新的对象
public class UserDaoImpl implements UserDao {
public void addUser() {
System.out.println("dao添加学生");
}
}
service：
public interface UserService {
void addUser();
}
serviceImpl：
@Service("userService")
public class UserServiceImpl implements UserService {
// Autowired按照类型匹配 UserDao
// Qualifier 根据bean的name匹配 UserDao
// @Qualifier("userDao")
@Autowired
private UserDao userDao;
@Value("myName")
private String name;
public void addUser() {
userDao.addUser();
System.out.println("service层添加学生");
}
}
test类：
//测试类整合spring后可以使用注解
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml") //加载applicationContext.xml配置文件
public class UserServiceTest {
// @Test
// public void UserServiceImpl(){
//测试类没有整合spring
// ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
// UserService userService = app.getBean("userService", UserService.class);
// userService.addUser();
// }
@Autowired
private UserService userService;
@Test
public void UserServiceImpl() {
userService.addUser();
}
}
结果：
