1、概念(先了解,原理后面再写)
1、spring是一个轻量级的开源的JavaEE框架(引入jar包的数量以及体积都比较小)
2、spring框架可以解决企业应用开发的复杂性
3、spring里面有很多组成部分,IOC和AOP两个核心部分
①IOC:Inversion of Control控制反转,把创建对象的过程交给spring管理,不需要手动new对象
②AOP:Aspect Oriented Programming面向切面编程,再不修改源代码的情况下给功能进行添加,对功能进行增强
4、spring框架的特点
①方便解耦,简化开发
②支持AOP编程,不改变源代码给项目加功能
③junit方便程序测试
④方便和其他框架进行整合
⑤方便进行事务操作
⑥降低API开发难度,对很多多西提供了封装如jdbc
2、入门案例
导入jar包,只需要导入基本jar包
导入4个基本的核心包以及一个log包
创建一个普通的类,在这个类中创建一个普通方法,创建Spring配置文件,在配置文件中配置要创建的对象
①spring的配置文件时xml文件,clas为包的全限定名称
<?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.wchao.User"/>
</beans>
public class TestSpring5 {
@Test
public void testAdd(){
// 1.加载spring配置文件 ,当配置文件和src在同一级目录之下时就使用这个可以
ApplicationContext context=new ClassPathXmlApplicationContext("bean01.xml");
// 当配置文件和src不在同一级目录之下就用这个
ApplicationContext context1=new FileSystemXmlApplicationContext("bean01.xml");
// 2.获取配置创建的对象
User user = context.getBean("user", User.class);
// User user = context1.getBean("user", User.class);
System.out.println(user);
user.add();
}
}
3、IOC容器
什么是IOC:其中最常见的方式叫做依赖注入(Dependency Injection,简称DI),把对象的创建以及对象之间的调用过程,交给spring进行管理
使用ioc的目的,为了降低耦合度
3.1 IOC底层原理
底层原理:xml解析、工厂模式、反射
3.2 IOC接口(BeanFactory)
ioc思想基于ioc容器完成,ioc容器底层就是对象工厂,spring提供了ioc容器实现的两种方式,两个接口BeanFactory和ApplicationContext
BeanFactory:ioc容器基本的实现方式,一般开发中不使用spring内部使用的接口,一般不提供开发人员使用
特点是加载配置文件的时候不会创建对象,在获取对象,使用对象的时候才会去加载对象
ApplicationContext:BeanFactory的子接口,提供了更多更强大的功能,一般是面向开发人员使用的
在加载配置文件的时候,就会把在配置文件中的对象进行创建
3.3 IOC操作Bean管理(基于xml)
Bean管理:2个操作,第一由spring创建对象,第二由spring注入属性
Bean管理操作有两种方式,1.xml配置文件方式实现,2基于注解方式实现
①基于xml方式创建对象
在spring的配置文件中使用bean标签,标签里面添加对应的属性,在bean标签有很多属性,id:给对象起个别名,唯一标识,通过getBean可以找到他,class:出创建对象所在的全路径(包类路径),name跟id属性一样,id不能加特殊符号name可以加比如/,创建对象的时候,默认是无参构造的
②基于xml方式注入属性
DI:依赖注入,注入属性,DI是ioc中的一种具体实现,需要在创建对象的基础之上完成,
第一种注入方式使用set方式进行注入(创建一个类,里面定义属性和对应的set方法,第二步在spring配置文件中,先配置对象创建,在配置属性注入),第二种注入方式使用有参构造注入(创建一个类,定义属性,创建属性对应的有参构造方法,在spring额配置文件中进行配置),底层用的set方法
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 1. bean配置User对象创建-->
<bean id="user" class="com.wchao.User"/>
<!-- 2. set方法注入属性-->
<bean id="book" class="com.wchao.BookInjection">
<!-- 在bean标签里面使用property完成属性注入
name:类里面的属性名称
value:向属性里面注入的值-->
<property name="bname" value="易筋经"/>
<property name="bauthor" value="达摩老祖"/>
</bean>
<!-- 3. 有参构造注入属性-->
<bean id="order" class="com.wchao.Order">
<!-- 在bean标签里面使用constructor-arg完成属性注入
name:类里面的属性名称
index:有参构造的形参位置
value:向属性里面注入的值
-->
<constructor-arg name="oname" value="abc"/>
<constructor-arg index="1" value="China"/>
</bean>
<!-- 4. 使用p名称空间注入,可以简化基于xml配置方式
① 添加p名称空间在配置文件中
② 进行属性的注入,在bean里面进行操作,目的就是为了简化操作
-->
<bean id="book1" class="com.wchao.BookInjection" p:bname="九阳神功" p:bauthor="无名"/>
</beans>
IOC容器-Bean管理XML方式(注入空值和特殊符号)
字面量:属性的估计值,设置值的时候可以设置null值,当属性值包含特殊符号
<!-- 设置null属性:如下所示就表示向属性中设置一个null-->
<!-- <property name="address" >-->
<!-- <null/>-->
<!-- </property>-->
<!-- 属性值中有特殊符号 <> 就会报错
1. 可以使用转义解决 < >
2. 把带特殊符号的内容写道CDATA中去
-->
<property name="address" >
<value><![CDATA[<<南京>>]]>
</value>
</property>
</bean>
注入属性
外部bean:1创建两个类service和dao类2在service中调用dao里面的方法3在spring的配置文件中配置ref
bean.xml
<?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">
<!-- 先把service和dao对象进行创建-->
<bean id="userService" class="service.UserService">
<!-- 在userService中注入userDao对象
name属性值:类里面的属性名称
ref:代表你想引入的值,在bean中注入的对象值
-->
<property name="userDao" ref="userDaoImpl"/>
</bean>
<bean id="userDaoImpl" class="dao.UserDaoImpl"/>
</beans>
service层
public class UserService {
// 1. 创建UserDao类型的属性,生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add(){
System.out.println("service add...");
// userDao.update();
// 先创建UserDao对象 原始方式
// UserDao userDao=new UserDaoImpl();
userDao.update();
}
}
内部bean和级联赋值
①一对多关系:部门和员工,一个部门有多个员工,一个员工属于一个部门
部门是一,员工是多
②在实体类之间表示一对多关系,员工表示所属的部门,使用对象类型属性进行表示
③在spring的配置文件进行配置
内部bean的xml
<?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">
<!-- 内部bean的操作-->
<bean id="emp" class="com.bean.Emp">
<!-- 先设置两个普通的属性-->
<property name="ename" value="lucy"/>
<property name="gender" value="female"/>
<!-- 设置对象类型属性 这个就叫做内部bean,也可以通过ref外部bean-->
<property name="dept">
<bean class="com.bean.Dept">
<property name="dname" value="安保部"/>
</bean>
</property>
</bean>
</beans>
员工类
package com.bean;
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;
}
public void add(){
System.out.println(ename+""+gender+""+dept);
}
}
注入属性-级联赋值
第一种写法
<?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">
<!-- 级联赋值-->
<bean id="emp" class="com.bean.Emp">
<!-- 先设置两个普通的属性-->
<property name="ename" value="lucy"/>
<property name="gender" value="female"/>
<!--级联赋值 跟注入外部bean差不多,只不过加了属性-->
<property name="dept" ref="dept"/>
</bean>
<bean id="dept" class="com.bean.Dept">
<property name="dname" value="财务部"/>
</bean>
</beans>
第二种写法get通过对象.属性取出一定要有get方法
<?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">
<!-- 级联赋值-->
<bean id="emp" class="com.bean.Emp">
<!-- 先设置两个普通的属性-->
<property name="ename" value="lucy"/>
<property name="gender" value="female"/>
<!--级联赋值 这种方法选哟有对应的dept的get方法-->
<property name="dept.dname" value="技术部"/>
</bean>
<bean id="dept" class="com.bean.Dept"/>
</beans>
XML注入集合属性
1.注入数组类型属性
2.注入List集合类型属性
3.注入Map集合类型属性
xml文件
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 1. bean配置User对象创建-->
<bean id="student" class="byue.collectionType.Student">
<!-- 数组类型的属性注入用array标签或者list标签都可以-->
<property name="courses">
<array>
<value>java课程</value>
<value>mysql课程</value>
</array>
</property>
<property name="list">
<list>
<value>张三</value>
<value>李四</value>
</list>
</property>
<property name="map">
<map>
<entry key="JAVA" value="java"/>
<entry key="PYTHON" value="python"/>
</map>
</property>
<property name="set">
<set>
<value>mysql</value>
<value>redis</value>
</set>
</property>
</bean>
</beans>
Student类
package byue.collectionType;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Student {
// 数组类型属性
private String[] courses;
// list集合类型属性
private List<String> list;
// Map集合类型属性
private Map<String,String> map;
// set集合类型属性
private Set<String> set;
public void setSet(Set<String> set) {
this.set = set;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public void test(){
System.out.println(Arrays.toString(courses));
System.out.println(list);
System.out.println(map);
System.out.println(set);
}
}
在Spring里面有两种类型的bean,一种是自己创建的普通bean,还有一种就是工厂bean,FactoryBean
普通bean:在spring的xml配置文件中定义什么类型返回的就是什么类型
FactroyBean:在配置文件中定义bean类型可以和返回类型不一样
第一步:创建一个类,让这个类作为工厂bean,实现接口FactoryBean
第二步:实现接口里面的方法,在实现的方法中定义返回的bean类型
xml文件
<?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"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<bean id="myBean" class="byue.factoryBean.MyBean"></bean>
</beans>
FactoryBean
package byue.factoryBean;
import byue.collectionType.Course;
import org.springframework.beans.factory.FactoryBean;
public class MyBean implements FactoryBean<Course> {
// 定义返回的bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("adc");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return FactoryBean.super.isSingleton();
}
}
bean的作用域:在spring里面,设置bean实例是单实例还是多实例
在spring里面,默认情况下,bean是单实例对象
如何设置bean是单实例还是多实例对象,bean标签有scope属性值
第一个 默认值 singleton,表示单实例对象
第二个 prototype,表示多实例对象
singleton和prototype的区别
第一:singleton表示单实例,prototype表示多实例
第二:设置scope的值是singleton的时候,不设置默认就是他,加载Spring配置文件的时候就会创建单实例对象,设置prototype的时候,不是在加载spring配置文件的时候创建对象,是在调用getBean的时候创建多实例对象
3.3.1Bean的声明周期
一个对象从创建到销毁的过程
①创建Bean实例,通过构造器创建bean实例(无参构造)
②为bean里面的属性设置值和对其他bean的引用(调用set方法)
③调用bean的初始化方法(需要进行配置初始化的方法 )
④bean可以使用了(对象获取到了)
⑤当容器关闭的时候,调用bean的销毁的方法(需要进行配置销毁的方法)
3.3.2添加后置处理器(七状态模型)
完整的操作其实还有2步叫做bean的后置处理器:bean初始化之前和之后分别调用的方法,总共7步
①创建Bean实例,通过构造器创建bean实例(无参构造)
②为bean里面的属性设置值和对其他bean的引用(调用set方法)
后置处理器:把bean的实例传递给bean的后置处理器执行postProcessBeforeInitialization这个方法
③调用bean的初始化方法(需要进行配置初始化的方法 )
后置处理器:把bean的实例传递给bean的后置处理器执行postProcessAfterInitialization这个方法
④bean可以使用了(对象获取到了)
⑤当容器关闭的时候,调用bean的销毁的方法(需要进行配置销毁的方法)
(1)创建类,实现接口BeanPostProcessor,创建后置处理器
(2)在xml文件中配置bean实例,他会对所有的bean实例都进行装配
3.4 Bean管理xml方式(自动装配)
手动装配:自己在xml文件中给bean实例实例化,以及给实例的属性赋值
自动装配:根据指定装配规则(属性名称或者属性类型),Spring自动讲匹配的属性值进行注入
自动装配的过程
3.5 Bean管理xml方式(外部属性文件)
xml文件引入properties文件中的固定属性进行使用,以数据库配置为例
1、直接配置数据库信息
①配置德鲁伊连接池
②引入德鲁伊连接池依赖jar包
③手动进行配置连接信息
2、引入外部属性文件配置数据库连接池
①创建外部属性文件,properties格式文件,数据库信息
②把外部properties属性文件引入到spring配置文件中
第一步引入context名称空间
第二步在spring配置文件中使用标签引入外部属性文件
4、基于注解实现创建对象以及属性
注解:是代码的特殊标记@注解名称(属性名=属性值,…),注解可以作用在类、方法、属性上
使用目的:让xml配置更加简洁,更加优雅
4.1 Spring针对Bean管理中创建对象提供的注解
①@Component:普通组件
②@Service:一般用在业务逻辑层
③@Controller:一般用在web层上
④@Repository:一般用在dao层上
上面的四个注解功能是一样的,都是用来创建bean的实例,并没有区分哪个注解非要用在哪个层上面,只是为了开发更加的清晰当前组件所代表的角色
4.2基于注解方式实现对象的创建
第一步:引入依赖,spring的lib目录中可以找到
第二步:开启组件扫描,指定扫描的位置
第三步:创建类,在类上面添加创建对象注解
第四步:测试调用,单例bean
第二步:开启组件扫描,指定扫描的位置
告诉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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 1. 如上述所示加入context空间,
①开启组件扫描 如果想扫描多个包,中间加上逗号就可以
②写扫描包的上层目录,一定要注意不多项目的时候包的路径一定不能一样
-->
<context:component-scan base-package="com.wchao"/>
</beans>
第三步:创建类,在类上面添加创建对象注解
第四步:测试调用,单例bean
4.2.1开启组件扫描细节配置
如果不写use-default-filters则默认为true他会扫描包中的所有东西
<context:component-scan base-package="com.wchao" use-default-filters="false"/>
4.2基于注解方式实现属性注入
①@Autowired:根据属性类型进行自动装配
②@Qualifier:根据属性名称进行注入
③@Resource:可以根据类型注入,也可以根据名称注入(它本身是javax扩展包中的注解,spring更建议用别的注解,应为不是他自己的注解)
④@Value:注入普通类型属性
第一步:把service和dao的对象都进行创建,都给类加上创建对象的注解
第二步:在service注入dao,autowired提供了set方法,不用写set方法
Qualifier这个注解的使用要和Autowired这个注解一起使用
Resource不写里面的属性就是根据属性注入,加上里面的name属性就是根据id注入
5、纯注解开发
以上配置文件中只有一行代码就是开启组件扫描
1创建配置类,替代xml配置文件,在实际开发中一般用Spring-Boot进行开发,它简化了Spring