Spring
1.Spring
1.1概述
1.Spring的系统架构图
1.2核心容器
1.IoC控制反转
- IoC(Inversion of Control): 使用对象时,由主动new产生对象转换为由外部提供对象,此过程中对象创建控制权由程序转移到外部,此思想称为控制反转。
- Spring提供了一个容器,称为IoC容器,用来充当IoC思想中的外部
- IoC容器负责对象的创建,初始化等一系列工作,被创建或被管理的对象在IoC容器中统称为Bean
2.DI(Dependency Injection)依赖注入
- 在容器中建立Bean和Bean之间的依赖关系的整个过程,称为依赖注入
3.目标:充分解耦
- 使用IoC容器管理Bean(IoC)
- 在IoC容器内将有依赖关系的bean进行关系绑定(DI)
4.IoC入门案例
1.思路分析
- 管理什么?(Service与Dao)
- 如何将被管理的对象告知IoC容器?(配置)
- 被管理的对象交给IoC容器,如何获取到IoC容器?(接口)
- IoC容器得到后,如何从容器中获取Bean?(接口方法)
- 使用Spring导入哪些坐标?(pom.xml)
2.导入Spring坐标
<!--引入Spring依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.20.RELEASE</version>
</dependency>
3.定义Spring管理的类
4.创建Spring配置文件,配置对应类作为Spring管理的bean
<?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:唯一性,给配置的此bean起名字
class:表示bean定义的类型
-->
<bean id="bookDaoImpl" class="com.it.dao.BookDaoImpl"></bean>
<bean id="bookServiceImpl" class="com.it.service.BookServiceImpl"></bean>
</beans>
5.初始化IoC容器,通过容器获取bean
@Test
public void Demo03() {
//获取IoC容器
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取bean
BookServiceImpl bookServiceImpl = context.getBean("bookServiceImpl", BookServiceImpl.class);
bookServiceImpl.save();
}
5.DI入门案例
1.思路分析
- 基于IoC管理bean
- Service中使用new形式创建的Dao对象是否保留(否)
- Service中需要的Dao对象如何进入到Service中?(提供方法)
- Service与Dao间的关系如何描述?(配置)
2.删除使用new的形式创建对象的代码并提供set方法
public class BookServiceImpl implements BookService {
private BookDaoImpl bookDao;
public void setBookDao(BookDaoImpl bookDao) {
this.bookDao = bookDao;
}
public void save(){
System.out.println("book service ");
bookDao.save();
}
}
3.配置Service与Dao之间的关系
<?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:唯一性,给配置的此bean起名字
class:表示bean定义的类型
-->
<bean id="bookDaoImpl" class="com.it.dao.BookDaoImpl"></bean>
<bean id="bookServiceImpl" class="com.it.service.BookServiceImpl">
<!--
property标签表示配置当前bean的属性
name:属性名
ref:属性类型配置的id值
-->
<property name="bookDao" ref="bookDaoImpl"></property>
</bean>
</beans>
6.bean基础配置
1.bean基础配置
2.bean别名的配置
3.bean作用范围(bean创建时实例的数量)的配置
- 在bean标签中使用scope属性,值为singleton: 单例,prototype:非单例
<!--
配置bean
id:唯一性,给配置的此bean起名字
class:表示bean定义的类型
name:别名 多个别名之间可以用 ",或;或空格"分开
-->
<bean id="bookServiceImpl" class="com.it.service.BookServiceImpl" scope="prototype">
<!--
property标签表示配置当前bean的属性
name:属性名
ref:属性类型配置的id值
-->
<property name="bookDao" ref="bookDaoImpl"></property>
</bean>
7.bean实例化
1.bean是如何创建出来的
2.bean实例化的三种形式
①无参构造函数
②静态工厂(了解)
③实例工厂(了解)
- FactoryBean(常用)
3.FactoryBean(常用)步骤
- 创建以下类和接口
public interface UserDao {
public void save();
}
public class UserDaoImpl implements UserDao{
public void save() {
System.out.println("user dao save ...");
}
}
//实现接口FactoryBean
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
//代替原始实例工厂中创建对象的方法
public UserDao getObject() throws Exception {
return new UserDaoImpl();
}
//返回所创建类的Class对象
public Class<?> getObjectType() {
return UserDao.class;
}
//返回实例对象的个数(true:单例 )
@Override
public boolean isSingleton() {
return false;
}
}
2.配置文件
<bean id="userDao" class="com.it.Factory.UserDaoFactoryBean"/>
3.测试
@Test
public void test02(){
ApplicationContext ctx = new
ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao1 = (UserDao) ctx.getBean("userDao");
UserDao userDao2 = (UserDao) ctx.getBean("userDao");
System.out.println(userDao1);
System.out.println(userDao2);
userDao1.save();
}
8.bean的生命周期
1.生命周期:从创建到消亡的完整过程
2.bean生命周期:bean从创建到消亡的完整过程
3.bean生命周期控制:在bean创建后到销毁前做一些事情
(1)关于Spring中对bean生命周期控制提供了两种方式:
- 在配置文件中的bean标签中添加
init-method
和destroy-method
属性 - 类实现
InitializingBean
与DisposableBean
接口,这种方式了解下即可。
(2)关闭容器的两种方式:
- ConfigurableApplicationContext是ApplicationContext的子类
- close()方法
- registerShutdownHook()方法
9.setter注入
10.构造器注入
11.自动装配
12.集合注入
注解开发内容
···············
以上内容已经学过不在这记笔记了
1.3AOP
1.3.1AOP简介
1.AOP概念与作用
- AOP:面向切面编程,一种编程范式,指导开发者任何组织程序结构
- 作用:在不惊动原始设计的基础上为其进行功能的增强
- Spring理念:无入侵式/无侵入式编程
2.AOP核心概念
- 连接点:程序执行过程中的任意位置,粒度为执行方法,抛出异常,设置变量等(在SpringAOP中,理解为方法的执行)
- 切入点:匹配连接点的式子(在SpringAOP中,一个切入点可以只描述一个方法,也可以匹配多个方法)
- 通知:在切入点处执行的操作,也就是共性操作(在SpringAOP中,功能最终已方法的形式呈现)
- 通知类:定义通知的类
- 切面:描述通知与切入点之间的对应关系
1.3.2AOP入门案例
1.先创建一个基本的环境
2.导入依赖
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
3.定义通知类,切入点,切面
@Component//告诉Spring来加载我
@Aspect//告诉Spring这个东西是用来做AOP的
//通知类
public class MyAdvice {
//切入点
@Pointcut("execution(void com.it.dao.BookDao.update())")
private void pt(){}
//在切入点的什么位置执行
@Before("pt()")//切面
//通知,共性功能
public void method(){
System.out.println(System.currentTimeMillis());
}
}
4.开启Spring对AOP注解驱动支持
@Configuration
@ComponentScan("com.it")
@EnableAspectJAutoProxy//告诉Spring项目里面用注解开发的AOP
public class SpringConfig {
}
1.3.3AOP工作流程
1.Spring容器启动
2.读取所有切面配置中的切入点
3.初始化bean, 判定bean对应的类中的方法是否匹配到任意切入点
- 匹配失败,创建对象
- 匹配成功,创建原始对象的代理对象
4.获取bean执行方法
- 获取bean,调用方法并执行,完成操作
- 获取的bean是代理对象时,根据代理对象的运行模式运行原始方法与增强的内容,完成操作
1.3.4AOP切入点表达式
1.切入点:要进行增强的方法
2.切入表达式:要进行增强的方法的描述方式
描述方式一:执行包下接口中的无参update方法(这种,接口的所有实现类的此方法都可以连接到通知)
描述方式二:执行包下实现类中的无参update方法
1.语法格式
- 标准格式:动作关键字 (访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名)
- 动作关键字:描述切入点的行为动作,例如:execution表示执行到指定切入点
- 访问修饰符,异常名可以省略
- execution(void com.it.dao.BookDao.update())
2.通配符
- *:单个独立的任意符号,可以独立出现,也可以作为前缀或后缀的匹配符出现
:多个连续的任意符号,可以独立出现,常用于简化包名与参数的书写
- + :专用于匹配子类类型
3.书写技巧
1.3.5AOP通知类型
1.AOP通知描述了抽取的共性功能,根据共性功能抽取的位置不同。最终运行代码时要将其加入到合理的位置
2.AOP通知共分为五种类型
-
前置通知@Before
-
后置通知@After
-
环绕通知(重要)@Arount
-
返回后通知(了解)@AfterReturning
-
抛出异常后通知(了解)@AfterThrowing
1.3.6AOP通知获取数据
1.获取参数(重点)
- 都可以获取参数
- 环绕通知:使用ProceedingJoinPoint pjp 形参
- 其它:使用JoinPoint jp 形参
@Before("pt()")
public void before(JoinPoint jp) {
//获取参数
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("before advice ..." );
}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
//获取形参
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
Object ret = pjp.proceed();
return ret;
}
2.获取返回值
- 只有环绕通知,返回后通知
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
//获取形参
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
//获取返回值
Object ret = pjp.proceed();
return ret;
}
//获取返回值
@AfterReturning(value = "pt()",returning = "obj")
public void afterReturning(JoinPoint jp,Object obj) { //一定是JoinPoint jp在第一个形参位置
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("afterReturning advice ..." + obj);
}
3.获取异常(了解)
- 只有环绕通知,抛出异常后通知
@Around("pt()")
public Object around(ProceedingJoinPoint pjp){
//获取形参
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
//获取返回值
Object ret = null;
//获取异常
try {
ret = pjp.proceed();
} catch (Throwable e) {
System.out.println(e);
}
return ret;
}
@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(JoinPoint jp,Throwable t) {
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("afterThrowing advice ..." + t);
}
1.4事务
1.4.1事务简介
1.事务作用:在数据层保障一系列的数据库操作同成功同失败
2.Spring事务作用:在数据层或业务层保障一系列的数据库操作同成功同失败
3.实现事务的步骤:
-
①在业务层接口上添加Spring事务管理(@Transactional)
-
②设置事务管理器
-
③开启注解式事务驱动(@EnableTransactionManagement)
1.4.2事务角色
1.事务管理员:发起事务方,在Spring中通常指代业务层开启事务的方法
2.事务协调员:加入事务方,在Spring中通常指代数据层方法,也可以是业务层方法
1.4.3事务属性
1.事务配置
2.事务传播行为
- 概述:事务协调员对事务管理员所携带事务的态度
- 使用@Transactional(propagation= Propagation.值)