1.框架概述
- Spring 是轻量级的开源的 JavaEE 框架
- Spring 可以解决企业应用开发的复杂性
- Spring 有两个核心部分：IOC 和 Aop
- IOC：控制反转，把创建对象过程交给 Spring 进行管理
- Aop：面向切面，不修改源代码进行功能增强
- 特点：
- 方便解耦，简化开发
- Aop 编程支持
- 方便程序测试
- 方便和其他框架进行整合
- 方便进行事务操作
- 降低 API 开发难度
2.入门案例
- 创建普通类以及普通方法：
public class User { public void add(){ System.out.println("add..."); } }
- 创建 Spring 配置文件，在配置文件配置创建的对象：
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!--配置 User 对象创建--> <bean id="user" class="com.psj.User"></bean> </beans>
- 进行测试代码编写：
// 1.加载spring配置文件 ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); // 2.获取配置创建的对象 User user = context.getBean("user", User.class); System.out.println(user); user.add();
3.IOC
3.1 什么是IOC
- 控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理
- 目的是为了耦合度降低
- 入门案例就是 IOC 实现
3.2 底层原理
- 假设要在UserService类中调用UseDao的add方法，传统方式的耦合度太高，假设UserDao路劲改变了，调用的UserDao的其他类都要修改代码：
- 为了降低耦合度，可以使用工厂模式，这样其他要使用UserDao类的类通过调用工厂类间接实现，如果UserDao路径改变，此时不需要修改UserService类的代码，只要修改工厂类的代码即可：
- 在工厂模式中还是存在一定的耦合，所以采用IOC进一步降低耦合，三个重要的因素是xml解析、工厂模式以及反射。即使路径改变，也只需要修改xml文件即可：
IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂
Spring 提供 IOC 容器实现两种方式：
BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用(加载配置文件时候不会创建对象，在获取对象才去创建对象)：// 使用BeanFactory时该步加载配置文件，此时不会创建对象，等到执行getBean才会创建对象 BeanFactory context = new ClassPathXmlApplicationContext("bean.xml"); User user = context.getBean("user", User.class);
ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用(加载配置文件时候就会把在配置文件对象进行创建)：// 使用ApplicationContext时，假如配置文件中有很多的bean对象，在该步加载配置文件时都会创建，不管用不用 ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); User user = context.getBean("user", User.class);tips：
在开发中一般使用
ApplicationContext，这样在启动服务器的时候就能创建好对象，而不是等到代码要创建对象时再创建
ApplicationContext有两个实现类：
FileSystemXmlApplicationContext：配置文件路径要求是在盘符下的路径
ClassPathXmlApplicationContext：配置文件路径要求是相对于src目录下的路径
3.3 操作 Bean 管理
3.3.1 什么是 Bean 管理
- Bean 管理指的是两个操作：
- Spring 创建对象：传统方式创建类的实例是通过
new XXX，Spring也是调用构造器，只不过实现方式改变了- Spirng 注入属性：传统方式给类的属性赋值(注入属性)是通过set方法或者使用有参构造器，Spring也可以通过这两种方式，只不过实现方式变了
- Bean 管理操作有两种方式：
- 基于 xml 配置文件方式实现
- 基于注解方式实现
3.3.2 基于 xml 方式
创建对象：
<bean id="user" class="com.psj.User"></bean>
- 在 bean 标签有很多属性：
- id 属性：唯一标识，就是一个别名
- class 属性：类全路径（包类路径）
- name属性：和id属性作用一样，使用几率很小
- 创建对象时候，默认执行无参数构造方法完成对象创建。假设类中只有有参构造器(默认创建的无参构造器就不存在了)，还是使用一样的方式创建对象会报错
注入属性：
- 通过set方法注入：
<bean id="user" class="com.psj.User"> # 在类中一定要有相应属性的set方法。该name为类中的属性，不同于bean中的name <property name="username" value="psj"></property> </bean>
- 通过有参构造器注入：
<bean id="user" class="com.psj.User"> # 在类中一定要有相应的有参构造器(假设类中只有有参构造器，没写constructor-arg标签前会报错，写完后不会报错) <constructor-arg name="username" value="psj"></constructor-arg> </bean>
- p 名称空间注入：
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" # 添加 p 名称空间在配置文件中 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> # 不同于constructor-arg，类中只有有参构造器时会报错 <bean id="user" class="com.psj.User" p:username="psj"></bean> </beans>
注入其他类型属性(都采取set方法注入)：
- 注入null 值：要给username设置null值，直接使用
<property name="username" value=null></property>是不行的<bean id="user" class="com.psj.User"> <property name="username"> <null/> </property> </bean>
- 注入包含特殊符号的属性值：设置的值中包括了特殊符号，直接采取
<property name="username" value="<<psj>>">是不行的#1.把<和>进行转义 < > <bean id="user" class="com.psj.User"> <property name="username"> <value><<psj>></value> </property> </bean> <bean id="user" class="com.psj.User"> <property name="username" value="<<psj>>"></property> </bean> #2.把带特殊符号内容写到 CDATA <bean id="user" class="com.psj.User"> <property name="username"> <value><![CDATA[<<psj>>]]></value> </property> </bean>
- 注入外部 bean：要实现UserService类调用UserDao类的操作
# UserDaoImpl类 public class UserDaoImpl implements UserDao{ @Override public void update() { System.out.println("DAO UPDATE"); } } # UserService类 public class UserService { // 要在xml中注入属性，需要set方法，而set方法需要在类中创建对象 // 所以不是使用了Spring就可以完全不在类中创建对象 private UserDao userDao1; public void setUserDao1(UserDao userDao1) { this.userDao1 = userDao1; } public void add(){ System.out.println("service add..."); userDao1.update(); } }<!--创建service和dao对象--> <bean id="userService" class="com.psj.service.UserService"> <!--注入UserDao对象--> <!--name是在UserService中创建的UserDao类型的属性名称 ref是创建的UserDao类的bean标签id值--> <property name="userDao1" ref="userDao"></property> </bean> <!--不要调用UserDao，这是接口，接口不能实例化--> <bean id="userDao" class="com.psj.dao.UserDaoImpl"></bean>// 1.加载spring配置文件 ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); // 2.获取配置创建的对象 UserService userService = context.getBean("userService", UserService.class); userService.add(); // 输出service add...和DAO UPDATE
- 注入内部 bean：以一对多关系中部门和员工为例
// 部门类 public class Dept { private String dname; public void setDname(String dname) { this.dname = dname; } } // 员工类 public class Emp { private String ename; private String gender; //一个员工属于某一个部门，使用对象形式表示 private Dept dept; public void setDept(Dept dept) { this.dept = dept; } public void setEname(String ename) { this.ename = ename; } public void setGender(String gender) { this.gender = gender; } }// bean.xml <bean id="emp" class="com.psj.bean.Emp"> <!--设置普通属性--> <property name="ename" value="psj"></property> <property name="gender" value="男"></property> <!--设置对象属性--> <property name="dept"> <bean id="dept" class="com.psj.bean.Dept"> <property name="dname" value="安保部"></property> </bean> </property> </bean> // 使用外部bean中ref效果是一样的 <bean id="emp" class="com.psj.bean.Emp"> <!--设置普通属性--> <property name="ename" value="psj"></property> <property name="gender" value="男"></property> <!--设置对象属性--> <property name="dept" ref="dept"></property> </bean> <bean id="dept" class="com.psj.bean.Dept"> <property name="dname" value="安保部"></property> </bean>
- 级联赋值：
// 方法1： <bean id="emp" class="com.psj.bean.Emp"> <!--设置普通属性--> <property name="ename" value="psj"></property> <property name="gender" value="男"></property> <!--设置对象属性--> <property name="dept" ref="dept"></property> </bean> <bean id="dept" class="com.psj.bean.Dept"> <property name="dname" value="安保部"></property> </bean> // 方法2： <bean id="emp" class="com.psj.bean.Emp"> <!--设置普通属性--> <property name="ename" value="psj"></property> <property name="gender" value="男"></property> <!--设置对象属性--> <property name="dept" ref="dept"></property> // 使用该方式的前提是Emp类中有getDept方法(Dept类中可以没有getDname方法) <property name="dept.dname" value="安保部"></property> </bean> <bean id="dept" class="com.psj.bean.Dept"></bean>
- 注入集合属性：
// Stu类 public class Stu { //1 数组类型属性 private String[] courses; //2 list 集合类型属性 private List<String> list; //3 map 集合类型属性 private Map<String, String> maps; //4 set 集合类型属性 private Set<String> sets; private List<Course> courseList; public void setCourseList(List<Course> courseList) { this.courseList = courseList; } public void setSets(Set<String> sets) { this.sets = sets; } public void setCourses(String[] courses) { this.courses = courses; } public void setList(List<String> list) { this.list = list; } public void setMaps(Map<String, String> maps) { this.maps = maps; } }<bean id="stu" class="com.psj.bean.Stu"> <!--数组类型属性注入--> <property name="courses"> <array> <value>java</value> <value>数据库</value> </array> </property> <!--list 类型属性注入--> <property name="list"> <list> <value>psj</value> <value>psw</value> </list> </property> <!--map 类型属性注入--> <property name="maps"> <map> <entry key="JAVA" value="java"></entry> <entry key="PHP" value="php"></entry> </map> </property> <!--set 类型属性注入--> <property name="sets"> <set> <value>MySQL</value> <value>Redis</value> </set> </property> </bean>
- 在集合中设置对象类型：
<bean id="course1" class="com.psj.bean.Course"> <property name="cname" value="Spring5"></property> </bean> <bean id="course2" class="com.psj.bean.Course"> <property name="cname" value="springMVC"></property> </bean> <property name="courseList"> <list> <ref bean="course1"></ref> <ref bean="course2"></ref> </list> </property>
- 使用 util 标签完成注入的提取:
<util:list id="nameList"> <value>psj</value> <value>psw</value> </util:list> <bean id="name" class="com.psj.bean.Book"> <property name="list" ref="nameList"></property> </bean>tips:
- DI(依赖注入)就是注入属性，注入属性不只是Spring的概念
3.3.3 IOC 操作 Bean 管理-FactoryBean
Spring 有两种类型 bean：普通 bean和工厂 bean（
FactoryBean）
- 普通 bean：在配置文件中定义 bean 属于什么类型就返回什么类型
// class中定义了Course类，在getBean("course1", Course.class)返回就是Course类 <bean id="course1" class="com.psj.bean.Course"> <property name="cname" value="Spring5"></property> </bean>
- 工厂 bean：返回类型可以和配置文件定义 bean的类型不一样(本质还是一个bean)
// 具体返回的类型由MyBean的getObject方法决定 <bean id="MyBean" class="com.psj.bean.MyBean"></bean>public class MyBean implements FactoryBean<Course>{ // 定义返回的类型,这里定义返回Course类 @Override public Course getObject() throws Exception { Course course = new Course(); course.setCname("psj"); return course; } @Override public Class<?> getObjectType() { return null; } @Override public boolean isSingleton() { return false; } } // 使用创建的工厂bean ... Course course = context.getBean("MyBean", Course.class); // 确定了要返回的类型后就写返回类型的class System.out.println(course);
3.3.4 IOC 操作 Bean 管理-bean 作用域
- bean作用域：即设置创建 bean 实例是单实例还是多实例(默认情况下为单实例对象）
// 单实例的情况 Book book1 = context.getBean("book", Book.class); Book book2 = context.getBean("book", Book.class); System.out.println(book1); // com.psj.bean.Book@33c911a1 System.out.println(book2); //com.psj.bean.Book@33c911a1
- 在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
- 设置 scope 值是
singleton时候，加载 spring 配置文件时候就会创建单实例对象- 设置 scope 值是
prototype时候，不是在加载 spring 配置文件时候创建 对象，在调用getBean 方法时候创建多实例对象# prototype:多实例，singleton:单实例 <bean id="book" class="com.psj.bean.Book" scope="prototype"></bean>
3.3.5 IOC 操作 Bean 管理-bean 生命周期
- 通过构造器创建 bean 实例（无参数构造）
- 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
- 调用 bean 的初始化的方法（需要进行配置初始化的方法）
- 使用bean （即已经获取到对象）
- 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
<bean id="orders" class="com.psj.bean.Orders" init-method="initMethod" destroy-method="destroyMethod"> <property name="oname" value="手机"></property> </bean>// Orders类的定义 public class Orders { //无参数构造 public Orders() { System.out.println("第一步 执行无参数构造创建 bean 实例"); } private String oname; public void setOname(String oname) { this.oname = oname; System.out.println("第二步 调用 set 方法设置属性值"); } //创建执行的初始化的方法 public void initMethod() { System.out.println("第三步 执行初始化的方法"); } //创建执行的销毁的方法 public void destroyMethod() { System.out.println("第五步 执行销毁的方法"); } } // ApplicationContext没有close方法，所以使用其子类ClassPathXmlApplicationContext ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); Orders orders = context.getBean("orders", Orders.class); System.out.println("第四步 获取创建 bean 实例对象"); // 需要手动让 bean 实例销毁 context.close(); // 输出结果 //第一步 执行无参数构造创建 bean 实例 //第二步 调用 set 方法设置属性值 //第三步 执行初始化的方法 //第四步 获取创建 bean 实例对象 //com.psj.bean.Orders@482bce4f //第五步 执行销毁的方法tips:
- 如果加上 bean 的后置处理器，则生命周期变为7步：
- 通过构造器创建 bean 实例（无参数构造）
- 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
- 把 bean 实例传递 bean 后置处理器的其中一个方法
postProcessBeforeInitialization- 调用 bean 的初始化的方法（需要进行配置初始化的方法）
- 把 bean 实例传递 bean 后置处理器的其中一个方法
postProcessAfterInitialization- 使用bean （即已经获取到对象）
- 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
<!--配置后置处理器,对于同一个配置文件中的所有bean都会自动生效--> <bean id="myBeanPost" class="com.psj.bean.MyBeanPost"></bean>public class MyBeanPost implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("在初始化前执行的方法"); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("在初始化后执行的方法"); return bean; } } //还是执行Orders orders = context.getBean("orders", Orders.class); //输出结果 //第一步 执行无参数构造创建 bean 实例 //第二步 调用 set 方法设置属性值 //在初始化前执行的方法 //第三步 执行初始化的方法 //在初始化后执行的方法 //第四步 获取创建 bean 实例对象 //com.psj.bean.Orders@1649b0e6 //第五步 执行销毁的方法
3.3.6 IOC 操作 Bean 管理-xml 自动装配
- 手动装配：需要在bean的property中定义name和value，即指明为哪个属性指定什么值
<bean id="orders" class="com.psj.bean.Orders" init-method="initMethod" destroy-method="destroyMethod"> <property name="oname" value="手机"></property> </bean>
自动装配：根据指定装配规则(属性名称或者属性类型)，Spring 自动将匹配的属性值进行注入
- 根据属性名称自动注入：
# 原始方式 <bean id="emp" class="com.psj.bean.Emp"> <property name="dept" ref="dept"></property> </bean> <bean id="dept" class="com.psj.bean.Dept"></bean> # 自动装配 <bean id="emp" class="com.psj.bean.Emp" autowire="byName"></bean> # 要求：被装配的bean中id值一定要和类中属性名字一样 <bean id="dept" class="com.psj.bean.Dept"></bean>
- 根据属性类型自动注入：
<bean id="emp" class="com.psj.bean.Emp" autowire="byType"></bean> # 如果该文件中还有一个id值不同但是class相同的bean对象，此时不清楚调用哪个bean。此时根据属性名称就不会报错 <bean id="dept" class="com.psj.bean.Dept"></bean>
3.3.7 IOC 操作 Bean 管理-外部属性文件
假设在bean中配置数据库信息：
- 直接进行配置：
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="url" value="jdbc:mysql://localhost:3306/jdbc"></property> <property name="username" value="root"></property> <property name="password" value="xxxx"></property> </bean>
- 引入外部的属性文件配置：
# 1.创建外部属性文件(假设名为jdbc.properties),写数据库信息 prop.driverClassName=com.mysql.jdbc.Driver prop.url=jdbc:mysql://localhost:3306/jdbc prop.username=root prop.password=xxxx# 2.在bean.xml引入 context 名称空间 xmlns:context="http://www.springframework.org/schema/context" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd # 3.使用标签引入外部属性文件 <context:property-placeholder location="classpath:jdbc.properties"/> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${prop.driverClassName}"></property> <property name="url" value="${prop.url}"></property> <property name="username" value="${prop.username}"></property> <property name="password" value="${prop.password}"></property> </bean>
3.3.8 IOC 操作 Bean 管理-基于注解方式
什么是注解：
- 注解的概念：代码特殊标记
- 格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
- 如何使用注解：注解作用在类上面，方法上面，属性上面
- 使用注解的目的：简化 xml 配置
Spring 针对 Bean 管理中为**创建对象(即创建bean实例)**提供的注解：
- @Component
- @Service
- @Controller
- @Repository
基于注解方式实现对象创建：
- 引入依赖：需要
Spring-aop-xxx.jar的jar包- 开启组件扫描：
<!--开启组件扫描 如果扫描多个包，多个包使用逗号隔开 --> <context:component-scan base-package="com.psj"></context:component-scan> <!--示例1： use-default-filters="false" 表示现在不使用默认filter(即扫描base-package下的所有注解)，自己配置 filter(即自己指定哪些类型的注解) context:include-filter ，设置扫描哪些内容 --> <context:component-scan base-package="com.psj" use-defaultfilters="false"> // 按注解类型过滤扫描的内容，此时只扫描Controller注解 <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan> <!--示例 2 下面配置扫描包所有内容 context:exclude-filter： 设置哪些内容不进行扫描(因为是扫描除了exclude外的所有，所以不设置use-defaultfilters) --> <context:component-scan base-package="com.psj"> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan>
- 创建类，在类上面添加创建对象注解：
// 等价于<bean id="empService" class="com.psj.service.EmpService"> @Service(value = "empService") // value可以省略，默认值是类名称(首字母小写) public class EmpService { public void add(){} }于注解方式实现属性注入基于注解方式实现属性注入：
@Autowired：根据属性类型进行自动装配// 在需要注入的类上添加注解(不是加在UserDao接口上，是加在实现类上) @Repository public class UserDaoImpl implements UserDao{ @Override public void update() { System.out.println("DAO UPDATE"); } } // service层 @Service(value = "empService") // 等价于<bean id="empService" class="com.psj.service.EmpService"> public class EmpService { // 等价于<bean ...> // <property name="userDao" ref="userDaoImpl"></property> // </bean> // 如果在xml中注入属性，需要写属性的set方法，使用注解则不要 @Autowired private UserDao userDao; public void add(){ userDao.update(); } }
@Qualifier：根据名称进行注入(需要和@Autowired一起使用)@Repository(value = "userDaoImpl2") public class UserDaoImpl2 implements UserDao{ @Override public void update() { System.out.println("DAO UPDATE2"); } } // service层 @Service(value = "empService") // 等价于<bean id="empService" class="com.psj.service.EmpService"> public class EmpService { @Autowired // 当一个接口有多个实现类时，这些实现类所属类型都是UserDao，所以根据类型进行注入则会失败 @Qualifier(value = "userDaoImpl2") private UserDao userDao; public void add(){ userDao.update(); } }
@Resource：可以根据类型注入，也可以根据名称注入@Service(value = "empService") // 等价于<bean id="empService" class="com.psj.service.EmpService"> public class EmpService { @Resource(name = "userDaoImpl2") // 如果没有加name就是按照类型注入 private UserDao userDao; public void add(){ userDao.update(); } }
@Value：注入普通类型属性@Service(value = "empService") // 等价于<bean id="empService" class="com.psj.service.EmpService"> public class EmpService { // 等价于<bean ...> // <property name="name" value="psj"></property> // </bean> @Value(value = "psj") private String name; }tips:
- 上述四个不同的注解可以混用，目的都创建bean实例
@Resource是javax.annotation下的类，JDK11无法直接使用
3.3.9 完全注解开发
上述完成了对创建对象和属性注入的注解操作，但是还是需要一个
bean.xml文件，而完全注解开发则把配置文件也用注解代替操作步骤：
- 创建配置类，替代 xml 配置文件：
@Configuration // 将该类作为配置类，代替xml文件 // 等价于配置文件中的<context:component-scan base-package="com.psj"></context:component-scan> @ComponentScan(basePackages = {"com.psj"}) public class SpringConfig { }
- 编写测试类：
// 不是加载配置文件，而是加载类 ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class); EmpService empService = context.getBean("empService", EmpService.class); empService.add();
874
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
