建设门户网站申请,域名网址注册,北京工商注册app,天河区网站公司目录1 IOC容器1.1 概念1.2 IOC的底层原理1.3 Spring中IOC容器的两种实现方式(两个接口)1.3.1 BeanFactory接口1.3.2 ApplicationContext接口1.3.3 为什么开发中使用ApplicationContext接口1.3.4 ApplicationContext接口的两个实现类1.4 IOC操作之bean管理1.4.0 bean是什么…
目录1 IOC容器1.1 概念1.2 IOC的底层原理1.3 Spring中IOC容器的两种实现方式(两个接口)1.3.1 BeanFactory接口1.3.2 ApplicationContext接口1.3.3 为什么开发中使用ApplicationContext接口1.3.4 ApplicationContext接口的两个实现类1.4 IOC操作之bean管理1.4.0 bean是什么1.4.1 基于xml配置文件方式实现1.4.1.1 创建对象1.4.1.2 注入属性的几种方式1.4.1.2.1 通过Setter方法注入属性1.4.1.2.2 使用有参数构造进行注入1.4.1.2.3 p 名称空间注入了解1.4.1.3 通过xml 注入其他类型属性1.4.1.3.1 字面量1.4.1.3.2 外部bean1.4.1.3.3 内部 bean1.4.1.3.4 级联赋值1.4.1.4 xml 注入集合属性1.4.1.4.1 注入数组、 List 集合、 Map 集合类型属性1.4.1.4.2 在集合里面设置对象类型值1.4.1.4.3 把集合注入部分提取出来1.4.2 Spring中两种类型的bean1.4.2.1 普通bean1.4.2.2 工厂 bean1.4.3 bean 作用域1.4.4 bean的生命周期1.4.4.1 7步生命周期1.4.4.2 初始化方法和销毁方法的配置1.4.4.3 添加后置处理器1.4.5 xml 自动装配1.4.5.1 根据属性名称自动注入1.4.5.1 根据属性类型自动注入1.4.6 xml引入外部属性文件1.4.7 基于注解方式实现bean管理1.4.7.1 什么是注解1.4.7.2 Spring 针对 Bean 管理中创建对象提供的注解1.4.7.3 基于注解方式实现对象创建的步骤1.4.7.4 开启组件扫描细节配置1.4.7.5 基于注解方式实现属性注入1.4.7.6 完全注解开发2 AOP--面向切面编程2.1 概念2.2 优点2.3 使用场景2.4 通过登录实例了解AOP2.5 AOP 底层使用动态代理2.5.1 两种情况的动态代理2.5.2 JDK 动态代理的实现2.6 AOP相关术语2.6.1 连接点2.6.2 切入点2.6.3 通知(增强)2.6.3.1 分类2.6.4 切面2.7 AOP的使用2.7.1 概述2.7.2 切入点表达式2.7.3 导包2.7.4 基于注解的AOP操作步骤2.7.4.1 创建被增强类2.7.4.2 创建增强类2.7.4.3 进行通知的配置2.7.4.4 配置不同类型的通知2.7.4.5 相同的切入点抽取 Pointcut注解2.7.4.6 测试类2.7.4.7 多个增强类对同一方法进行增强如何设置执行次序2.7.4.8 完全注解开发2.7.5 基于xml配置文件的AOP一般不使用2.7.5.1 创建增强类和被增强类2.7.5.2 在配置文件中进行配置3 JdbcTemplate3.1 概念3.2 准备工作3.2.1 导包3.2.2 在 spring 配置文件配置数据库连接池3.2.3 配置 JdbcTemplate 对象注入 DataSource3.2.4 创建 service 类创建 dao 类在 dao 中注入 jdbcTemplate 对象3.3 操作数据库3.3.1 创建数据库及表3.3.2 创建user表对应的实体类3.3.3 在UserService中调用UserDao中的方法3.3.4 在UserDao中操作数据库3.3.4.1 添加数据3.3.4.2 修改数据3.3.4.3 删除数据3.3.5 测试3.3.6 查询数据3.3.6.1 查询返回单个值3.3.6.2 查询返回单个对象3.3.6.3 查询返回对象集合3.3.7 批量操作3.3.7.1 批量添加3.3.7.2 批量修改3.3.7.3 批量删除4 事务4.1 概念4.2 四大特性4.3 Spring 事务管理4.3.1 概述4.3.2 两种方式4.3.3 Spring 事务管理 API4.3.4 注解声明式事务管理4.3.5 声明式事务管理参数配置4.3.5.1 Transactional中的参数4.3.5.2 propagation事务传播行为4.3.5.3 ioslation事务隔离级别4.3.5.4 timeout超时时间4.3.5.5 readOnly是否只读4.3.5.6 rollbackFor回滚4.3.5.7 noRollbackFor不回滚4.3.6 XML 声明式事务管理4.3.7 完全注解声明式事务管理5 Spring5 框架新功能5.1 日志功能使用步骤5.2 Spring5 框架核心容器支持Nullable 注解5.3 Spring5 核心容器支持函数式风格 GenericApplicationContext5.4 Spring5 整合 JUnit51 IOC容器
控制反转:所有的类都会在spring容器中登记告诉spring你是个什么东西你需要什么东西然后spring会在系统运行到适当的时候把你要的东西主动给你同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制也就是说控制对象生存周期的不再是引用它的对象而是spring。对于某个具体的对象而言以前是它控制其他对象现在是所有对象都被spring控制所以这叫控制反转。
1.1 概念
IOC是控制反转可以用来降低代码之间的耦合度将对象的创建和对象之间的调用过程交给spring管理IOC思想是基于容器实现的其底层就是对象工厂
1.2 IOC的底层原理
所使用的技术xml文件工厂模式反射实现流程 如何实现降低耦合度如果需要调整UserDao的位置那么只需要修改xml文件bean标签中UserDao的全类名即可从而降低了UserService和UserDao之间的耦合度。
1.3 Spring中IOC容器的两种实现方式(两个接口)
1.3.1 BeanFactory接口
IOC 容器基本实现是 Spring 内部的使用接口不提供开发人员进行使用。特点加载配置文件时候不会创建对象在获取对象使用才去创建对象是一种懒加载的方式。
1.3.2 ApplicationContext接口
BeanFactory 接口的子接口提供更多更强大的功能一般由开发人员进行使用。特点加载配置文件时候就会创建配置文件中的所有对象。
1.3.3 为什么开发中使用ApplicationContext接口
相比于ApplicationContextBeanFactory的懒加载貌似更加节省资源但是我们通常希望在服务启动的时候就完成这些消耗大量资源的事情—加载xml中所有的对象这样在后续的操作中就不需要使用资源来进行加载。
1.3.4 ApplicationContext接口的两个实现类
FileSystemXmlApplicationContext:创建对象时,传入的是绝对路径ClassPathXmlApplicationContext:创建对象时,传入的是相对于src的路径
ApplicationContext context new ClassPathXmlApplicationContext(bean1.xml);
ApplicationContext context1 new FileSystemXmlApplicationContext(D:\\研究生材料\\java代码\\spring-demo1\\src\\bean1.xml);1.4 IOC操作之bean管理
bean管理的两个操作: Spring创建对象;Spring注入属性; bean管理操作的两种方式: 基于xml配置文件方式实现基于注解方式实现 DI(依赖注入):是IOC的一种具体实现方式就是注入属性。所谓依赖注入即在运行期由容器将依赖关系注入到组件之中。讲的通俗点就是在运行期由Spring根据配置文件将其他对象的引用通过组件的提供的setter方法进行设定。
1.4.0 bean是什么
bean相当于类的代理通过bean可以实现创建对象和属性的注入。
1.4.1 基于xml配置文件方式实现
1.4.1.1 创建对象 在Spring中 配置文件中使用 bean 标签标签里面添加对应属性就可以实现对象创建;Spring默认使用无参构造实现对象的创建,所以类中一定要存在无参构造器;在 bean 标签有很多属性常用的属性包括: id 属性自定义唯一标识class 属性类全路径包类路径
1.4.1.2 注入属性的几种方式
1.4.1.2.1 通过Setter方法注入属性
在 spring 配置文件中进行配置,通过property标签给对象的属性赋值. User类 在单元测试方法中获取User对象
1.4.1.2.2 使用有参数构造进行注入
在 spring 配置文件中进行配置,通过constructor-arg标签实现属性注入
1.4.1.2.3 p 名称空间注入了解
使用 p 名称空间注入可以简化基于 xml 配置方式的Setter注入
第一步 添加 p 名称空间在配置文件中
第二步 进行属性注入在 bean 标签里面进行操作
1.4.1.3 通过xml 注入其他类型属性
对于自定义类属性的赋值需要使用外部bean、内部bean和级联赋值的方式。
1.4.1.3.1 字面量
null 值 bean iduser1 classcn.zhou.spring.User !--在property标签内添加null标签-- property namenamenull/null/propertyproperty nameage value19/property/bean属性值包含特殊符号 方式1可以将特殊符号转义例如可以转义为lt; gt;方式2把带特殊符号内容写到 CDATA![CDATA[内容]]这种方式必须将内容写在value标签中。 bean iduser1 classcn.zhou.spring.User property namenamevalue![CDATA[张三]]/value/property/bean1.4.1.3.2 外部bean
外部bean指的是被引用的bean直接定义在beans标签下与引用bean属于同一级。需要在xml配置文件中添加两个类的bean标签然后属性的值使用ref指向另一个类的bean具体操作如下
!--1 service 和 dao 对象创建--
bean iduserService classcom.atguigu.spring5.service.UserService!--注入 userDao 对象name 属性类里面属性名称ref 属性创建 userDao 对象 bean 标签 id 值--property nameuserDao refuserDaoImpl/property
/bean
bean iduserDaoImpl classcom.atguigu.spring5.dao.UserDaoImpl/beanpublic class UserService {//创建 UserDao 类型属性生成 set 方法private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao userDao;}public void add() {System.out.println(service add...............);userDao.update();} }1.4.1.3.3 内部 bean
内部 bean指的是被引用的bean定义再引用bean的内部两者是从属的关系。内部 bean和外部bean的区别内部bean只能被定义它的bean使用而外部bean可以被多个bean对象引用两者相当于局部变量和成员变量的关系。
!--内部 bean-- bean idemp classcom.atguigu.spring5.bean.Emp!--设置两个普通属性--property nameename valuelucy/propertyproperty namegender value女/property!--设置对象类型属性--property namedept!--在属性内部定义bean--bean iddept classcom.atguigu.spring5.bean.Deptproperty namedname value安保部/property/bean/property/bean1.4.1.3.4 级联赋值
方式1就是外部bean的写法 方式2直接在bean中使用property标签给自定义类的属性赋值注意需要在类中添加自定义类变量的getter方法。
1.4.1.4 xml 注入集合属性
1.4.1.4.1 注入数组、 List 集合、 Map 集合类型属性
创建类定义数组、list、map、set 类型属性生成对应 set 方法。 在 spring 配置文件进行配置
1.4.1.4.2 在集合里面设置对象类型值
将集合中的value标签改为ref标签在ref标签的bean属性中指定对象bean的id。 property namecourseListlistref beancourse1/refref beancourse2/ref/list/propertybean idcourse1 classcn.zhou.spring.collectiontest.Courseproperty namecourse_id value1/propertyproperty namecourse_name valuezs/property/beanbean idcourse2 classcn.zhou.spring.collectiontest.Courseproperty namecourse_id value2/propertyproperty namecourse_name valuels/property/bean1.4.1.4.3 把集合注入部分提取出来
导入util命名空间
?xml version1.0 encodingUTF-8?
beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexmlns:phttp://www.springframework.org/schema/pxmlns:utilhttp://www.springframework.org/schema/utilxsi:schemaLocationhttp://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd使用 util 标签完成 list 集合注入提取 !-- 提取 list 集合类型属性注入--util:list idlist1value12312/valuevalue12312/value/util:listproperty namelist reflist1/property1.4.2 Spring中两种类型的bean
1.4.2.1 普通bean
返回类型和配置文件中定义 bean 的类型相同。
// 配置文件中定义类型Student
bean idstu classcn.zhou.spring.collectiontest.Student // 创建对象时返回的类型StudentApplicationContext context new ClassPathXmlApplicationContext(bean2.xml);Student stu1 context.getBean(stu,Student.class);1.4.2.2 工厂 bean
在配置文件定义 bean 类型可以和返回类型不一样.
实现步骤 创建类让这个类作为工厂 bean实现接口 FactoryBean实现接口里面的方法在实现的方法中定义返回的 bean 类型。
public class MyBean implements FactoryBeanStudent {Overridepublic Student getObject() throws Exception {Student student new Student();return student;}Overridepublic Class? getObjectType() {return null;}Overridepublic boolean isSingleton() {return false;}
}1.4.3 bean 作用域
bean标签中的scope属性是用来设置bean 实例是单实例singleton还是多实例prototype默认情况下scope的值为singleton单实例单实例的情况下通过此bean标签创建的对象都是同一个而且单实例的bean的对象在xml文件加载的时候就已经创建完成多实例的情况下通过此bean标签创建的对象都是独立的多实例bean的对象不是在加载 spring 配置文件时候创建 对象在调用getBean 方法时候创建多实例对象。
1.4.4 bean的生命周期
1.4.4.1 7步生命周期
bean的生命周期总共有7步 1通过构造器创建 bean 实例无参数构造 2为 bean 的属性设置值和对其他 bean 引用调用 set 方法 3把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization 4调用 bean 的初始化的方法需要进行配置初始化的方法 5把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization 6bean 可以使用了对象获取到了 7当容器关闭时候调用 bean 的销毁的方法需要进行配置销毁的方法
对于ApplicationContext接口来说在加载xml配置文件时就会创建所有的对象所以前五步会执行第六步是主动获取已经创建好的对象第七步是容器关闭时销毁bean。
1.4.4.2 初始化方法和销毁方法的配置
在类中创建初始化和销毁的方法并且要将其配置到bean标签的属性中最后如果想要执行销毁方法需要手动销毁。
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(第五步 执行销毁的方法);} }bean idorders classcom.atguigu.spring5.bean.Orders init-methodinitMethod destroy-methoddestroyMethodproperty nameoname value手机/property
/beanTestpublic void testBean3() {
// ApplicationContext context
// new ClassPathXmlApplicationContext(bean4.xml);ClassPathXmlApplicationContext context new ClassPathXmlApplicationContext(bean4.xml);Orders orders context.getBean(orders, Orders.class);System.out.println(第四步 获取创建 bean 实例对象);System.out.println(orders);//手动让 bean 实例销毁context.close();}1.4.4.3 添加后置处理器
1创建类实现接口 BeanPostProcessor创建后置处理器 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; } } 2配置后置处理器后置处理器配置在beans标签下所以的bean都会调用后置处理器。
!--配置后置处理器--bean idmyBeanPost classcom.atguigu.spring5.bean.MyBeanPost/bean1.4.5 xml 自动装配
自动装配根据指定装配规则属性名称或者属性类型Spring 自动将匹配的属性值进行注入。
1.4.5.1 根据属性名称自动注入
!--实现自动装配Emp类中有一个Dept类型的属性bean 标签属性 autowire配置自动装配autowire 属性常用两个值byName 根据属性名称注入 注入值 bean 的 id 值和类属性名称一样byType 根据属性类型注入
--
bean idemp classcom.atguigu.spring5.autowire.Emp autowirebyName/bean
bean iddept classcom.atguigu.spring5.autowire.Dept/bean1.4.5.1 根据属性类型自动注入
根据属性类型自动注入时beans标签下只能存在一个此类型的属性。
bean idemp classcom.atguigu.spring5.autowire.Emp autowirebyType/beanbean iddept classcom.atguigu.spring5.autowire.Dept/bean1.4.6 xml引入外部属性文件 引入druid连接池依赖 jar 包 创建外部属性文件properties 格式文件写入数据库信息 把外部 properties 属性文件引入到 spring 配置文件中
需要先引入 context 名称空间
beans xmlnshttp://www.springframework.org/schema/beans xmlns:xsihttp://www.w3.org/2001/XMLSchema-instance xmlns:phttp://www.springframework.org/schema/p xmlns:utilhttp://www.springframework.org/schema/util xmlns:contexthttp://www.springframework.org/schema/context xsi:schemaLocationhttp://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 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd通过context标签引入外部属性文件
!--引入外部属性文件--context:property-placeholder locationclasspath:jdbc.properties/配置连接池
!--配置连接池--
bean iddataSource classcom.alibaba.druid.pool.DruidDataSourceproperty namedriverClassName value${prop.driverClass}/propertyproperty nameurl value${prop.url}/propertyproperty nameusername value${prop.userName}/propertyproperty namepassword value${prop.password}/property
/bean1.4.7 基于注解方式实现bean管理
1.4.7.1 什么是注解
1注解是代码特殊标记格式注解名称(属性名称属性值, 属性名称属性值…) 2使用注解注解作用在类上面方法上面属性上面 3使用注解目的简化 xml 配置
1.4.7.2 Spring 针对 Bean 管理中创建对象提供的注解
1Component 2Service 3Controller 4Repository
上面四个注解功能是一样的都可以用来创建 bean 实例但是为了在开发中更容易区分一般在不同类型的包下使用不同的注解。
1.4.7.3 基于注解方式实现对象创建的步骤
引入依赖 在xml配置文件中开启组件扫描 与1.4.6中类似需要先引入context命名空间然后使用context标签开启组件扫描。 !-- 如果需要扫描多个包包名使用逗号隔开或者可以写它们共同的父包 --context:component-scan base-packagecn.zhou.spring.annotation,cn.zhou.spring.dao/context:component-scan创建类在类上面添加创建对象注解
//注解括号中的内容可以省略默认值是首字母小写的类名称。
//UserService -- userService
Component(value userService) // 相当于bean iduserService class../
Component
public class UserService {public void add() {System.out.println(service add.......);} }获取对象和xml方式一样
// 单实例bean对象在加载xml文件时创建ApplicationContext context new ClassPathXmlApplicationContext(bean5.xml);
// 多实例bean对象在调用getBean时创建UserService service context.getBean(userService, UserService .class);System.out.println(service);1.4.7.4 开启组件扫描细节配置
设置扫描哪些内容 use-default-filters“false” 表示现在不使用默认 filter自己配置 filter默认的filter会扫描包下所有带注解的类。
!--示例 1context:include-filter 设置扫描哪些内容
--
context:component-scan base-packagecn.zhou.spring use-default-filtersfalse
// 表示只扫描包下注解为Controller和Component的类context:include-filter typeannotation expressionorg.springframework.stereotype.Controller/context:include-filter typeannotation expressionorg.springframework.stereotype.Component/
/context:component-scan设置不扫描哪些内容
!--示例 2下面配置扫描包所有内容context:exclude-filter 设置哪些内容不进行扫描
--
context:component-scan base-packagecom.atguigucontext:exclude-filter typeannotation
expressionorg.springframework.stereotype.Controller/
/context:component-scan1.4.7.5 基于注解方式实现属性注入
Autowired根据属性类型进行自动装配。如果接口的实现类有多个这种方式就无法使用。
1. 创建UserDao的实现类UserDaoImp 并添加创建对象的注解Repository
Repository
public class UserDaoImp implements UserDao{Overridepublic void add() {System.out.println(123);}
}2. 创建UserService类并添加创建对象的注解Service在属性userDao上添加注解 Autowired此时根据属性类型UserDao 进行自动装配。
Service
public class UserService {//定义 dao 类型属性//不需要添加 set 方法//添加注入属性注解AutowiredUserDao userDao;public void add(){userDao.add();}
}3. 调用userService对象的add方法ApplicationContext context new ClassPathXmlApplicationContext(bean5.xml);UserService userService context.getBean(userService, UserService.class);userService.add();Qualifier根据名称进行注入且此注解必须和Autowired一起使用
Service
public class UserService {AutowiredQualifier(value userDaoImp)UserDao userDao;public void add(){userDao.add();}
}Resource可以根据类型注入也可以根据名称注入但是此注解位于javax.annotation.Resource包下不是Spring中的注解一般不推荐使用
Service
public class UserService {
// Resource 根据类型进行注入Resource(name userDaoImp) // 根据名称进行注入UserDao userDao;public void add(){userDao.add();}
}Value注入普通类型(非自定义类)属性 Value(value 1)private int age;Value(value 张三)private String name;1.4.7.6 完全注解开发
1创建配置类替代 xml 配置文件
Configuration //作为配置类替代 xml 配置文件
ComponentScan(basePackages {com.atguigu}) // 开启组件扫描
public class SpringConfig {
}2编写测试类
Test
public void testService2() {//加载配置类不同于加载xml配置文件ApplicationContext context new AnnotationConfigApplicationContext(SpringConfig.class);// 获取对象与之前相同UserService userService context.getBean(userService,
UserService.class);System.out.println(userService);userService.add();2 AOP–面向切面编程
2.1 概念
AOP可以通过预编译方式和运行其动态代理实现在不修改源代码的情况下给程序动态统一添加某种特定功能的一种技术。
2.2 优点
利用AOP可以对业务逻辑的各个部分进行隔离从而使得业务逻辑各部分之间的耦合度降低提高程序的可重用性同时提高了开发的效率。
2.3 使用场景
将日志记录性能统计安全控制事务处理异常处理等代码从业务逻辑代码中划分出来通过对这些行为的分离可以将它们独立到非指导业务逻辑的方法中进而改变这些行为的时候不影响业务逻辑的代码。
2.4 通过登录实例了解AOP 2.5 AOP 底层使用动态代理
2.5.1 两种情况的动态代理 有接口情况使用 JDK 动态代理创建接口实现类代理对象增强类的方法。 没有接口情况使用 CGLIB 动态代理创建子类的代理对象增强类的方法。
2.5.2 JDK 动态代理的实现
1创建接口定义方法
public interface UserDao {public int add(int a,int b);public String update(String id);
}2创建接口实现类实现方法
public class UserDaoImpl implements UserDao {Overridepublic int add(int a, int b) {return ab;}Overridepublic String update(String id) {return id;}}3使用 Proxy 类创建接口代理对象
public class JDKProxy {public static void main(String[] args) {//创建接口实现类代理对象Class[] interfaces {UserDao.class};UserDaoImpl userDao new UserDaoImpl();UserDao dao (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));int result dao.add(1, 2);System.out.println(result:result);}}//创建代理对象代码
class UserDaoProxy implements InvocationHandler {//1 把创建的是谁的代理对象把谁传递过来//有参数构造传递private Object obj;public UserDaoProxy(Object obj) {this.obj obj;}//增强的逻辑Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//方法之前System.out.println(方法之前执行....method.getName() :传递的参数... Arrays.toString(args));//被增强的方法执行Object res method.invoke(obj, args);//方法之后System.out.println(方法之后执行....obj);return res;} }2.6 AOP相关术语
2.6.1 连接点
类中所有能够被增强的方法称为连接点。
2.6.2 切入点
真正被增强的方法称为切入点。
2.6.3 通知(增强)
实际增强的代码称为通知。
2.6.3.1 分类
前置通知Before在方法执行前增强。后置通知AfterReturning在方法执行后增强如果方法执行过程中出现异常则不执行。环绕通知Around在方法执行前后都增强。异常通知AfterThrowing方法执行过程中出现异常时增强。最终通知After无论方法是否出现异常都会执行的增强。(类似于finally)
2.6.4 切面
切面是一个动作是把通知应用到切入点的过程。
2.7 AOP的使用
2.7.1 概述
Spring 框架一般都是基于 AspectJ 实现 AOP 操作AspectJ 不是 Spring 组成部分独立 AOP 框架一般把 AspectJ 和 Spirng 框架一起使用进行 AOP 操作。基于 AspectJ 实现 AOP 操作的两种方式 1基于 xml 配置文件实现 2基于注解方式实现使用
2.7.2 切入点表达式
切入点表达式作用知道对哪个类里面的哪个方法进行增强语法结构 execution([权限修饰符] [返回类型] [类全路径].[方法名称] ([参数列表]) )权限修饰符为*表示任意权限都行返回类型可以省略参数列表使用(..)例子 对 com.atguigu.dao.BookDao 类里面的 add方法 进行增强execution(* com.atguigu.dao.BookDao.add(..))对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强:execution(* com.atguigu.dao.BookDao.* (..))对 com.atguigu.dao 包里面所有类类里面所有方法进行增强:execution(* com.atguigu.dao.*.* (..))
2.7.3 导包 2.7.4 基于注解的AOP操作步骤
2.7.4.1 创建被增强类
添加创建对象的注解Component
Component
public class User {public void add(){System.out.println(add...);}
}2.7.4.2 创建增强类
添加创建对象的注解Component
Component
public class UserProxy {public void before(){System.out.println(before....);}
}2.7.4.3 进行通知的配置
1在 spring 配置文件中开启注解扫描
?xml version1.0 encodingUTF-8?
beans xmlnshttp://www.springframework.org/schema/beans xmlns:xsihttp://www.w3.org/2001/XMLSchema-instance xmlns:contexthttp://www.springframework.org/schema/context xmlns:aophttp://www.springframework.org/schema/aop xsi:schemaLocationhttp://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 http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd!-- 开启注解扫描 --context:component-scan base-packagecom.atguigu.spring5.aopanno/context:component-scan2在增强类上面添加注解 Aspect
Component
Aspect //生成代理对象
public class UserProxy {Before(execution(* cn.zhou.spring.aopanno.User.add(..)))public void before(){System.out.println(before....);}
}4在 spring 配置文件中开启生成代理对象
!-- 开启 Aspect 生成代理对象--
aop:aspectj-autoproxy/aop:aspectj-autoproxy2.7.4.4 配置不同类型的通知
在增强类的里面在作为通知方法上面添加通知类型注解使用切入点表达式配置。
Component
Aspect
public class UserProxy {// 前置通知Before(execution(* cn.zhou.spring.aopanno.User.add(..)))public void before(){System.out.println(before....);}// 后置通知返回通知AfterReturning(execution(* cn.zhou.spring.aopanno.User.add(..)))public void afterReturn(){System.out.println(afterReturn....);}
// 最终通知After(execution(* cn.zhou.spring.aopanno.User.add(..)))public void after() {System.out.println(after.........);}
// 异常通知AfterThrowing(execution(* cn.zhou.spring.aopanno.User.add(..)))public void afterThrowing() {System.out.println(afterThrowing.........);}
// 环绕通知Around(execution(* cn.zhou.spring.aopanno.User.add(..)))public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println(环绕之前.........);//被增强的方法执行proceedingJoinPoint.proceed();System.out.println(环绕之后.........);}
}没有异常的执行结果
环绕之前.........
before....
add方法执行
环绕之后.........
after.........
afterReturn....有异常的执行结果
环绕之前.........
before....
add方法执行
after.........
afterThrowing.........通过对比两个执行结果可以看出发生异常后afterReturn和around之后都不会执行。
2.7.4.5 相同的切入点抽取 Pointcut注解 2.7.4.6 测试类 public static void main(String[] args) {ApplicationContext context new ClassPathXmlApplicationContext(bean1.xml);User user context.getBean(user, User.class);user.add();}2.7.4.7 多个增强类对同一方法进行增强如何设置执行次序
使用**Order(int i)**注解可以设置一个int类型的参数参数越小优先级越高。
2.7.4.8 完全注解开发 Configuration
ComponentScan(basePackages {com.atguigu})
EnableAspectJAutoProxy(proxyTargetClass true)
public class ConfigAop {
}2.7.5 基于xml配置文件的AOP一般不使用
2.7.5.1 创建增强类和被增强类
//增强类
public class BookProxy {public void before(){System.out.println(before...);}
}
//被增强类
public class Book {public void seal(){System.out.println(seal....);}
}2.7.5.2 在配置文件中进行配置
!--创建对象--
bean idbook classcn.zhou.spring.aopxml.Book/bean
bean idbookProxy classcn.zhou.spring.aopxml.BookProxy/bean!--配置 aop 增强--
aop:config!--切入点--
aop:pointcut idp expressionexecution(* cn.zhou.spring.aopxml.Book.buy(..))/!--配置切面--aop:aspect refbookProxy!--增强作用在具体的方法上--aop:before methodbefore pointcut-refp//aop:aspect
/aop:config3 JdbcTemplate
3.1 概念
JdbcTemplate是Spring 框架对 JDBC 进行了封装使用 JdbcTemplate 更方便实现对数据库操作。
3.2 准备工作
3.2.1 导包
mysql的jar包需要和自己电脑上的mysql版本相同如果使用的是mysql8就不能使用5.1.7版本的jar包。
3.2.2 在 spring 配置文件配置数据库连接池 bean iddataSource classcom.alibaba.druid.pool.DruidDataSourcedestroy-methodcloseproperty nameurl valuejdbc:mysql:///jdbc_test /property nameusername valueroot /property namepassword valueabc123 /property namedriverClassName valuecom.mysql.cj.jdbc.Driver //bean3.2.3 配置 JdbcTemplate 对象注入 DataSource
!-- JdbcTemplate 对象 -- bean idjdbcTemplate classorg.springframework.jdbc.core.JdbcTemplate!--注入 dataSource--property namedataSource refdataSource/property
/bean3.2.4 创建 service 类创建 dao 类在 dao 中注入 jdbcTemplate 对象
Repository
public class UserDaoImp implements UserDao{Autowiredprivate JdbcTemplate jdbcTemplate;
}Service
public class UserService {Autowiredprivate UserDao userDao;
}3.3 操作数据库
3.3.1 创建数据库及表 3.3.2 创建user表对应的实体类 3.3.3 在UserService中调用UserDao中的方法 3.3.4 在UserDao中操作数据库
update方法可以用于增删改
3.3.4.1 添加数据 3.3.4.2 修改数据 3.3.4.3 删除数据 3.3.5 测试 Testpublic void test(){ClassPathXmlApplicationContext context new ClassPathXmlApplicationContext(bean1.xml);UserService userService context.getBean(userService, UserService.class);userService.add(new User(1,24,张三));}3.3.6 查询数据
3.3.6.1 查询返回单个值 3.3.6.2 查询返回单个对象 3.3.6.3 查询返回对象集合 3.3.7 批量操作
3.3.7.1 批量添加 测试插入三条记录
3.3.7.2 批量修改 测试参数对应的位置要一致。 ListObject[] batchArgs new ArrayList();batchArgs.add(new Object[]{aa, 15, 1});batchArgs.add(new Object[]{bb, 16, 2});batchArgs.add(new Object[]{cc, 17, 3});userService.batchUpdate(batchArgs);3.3.7.3 批量删除 ListObject[] batchArgs new ArrayList();batchArgs.add(new Object[]{1});batchArgs.add(new Object[]{2});batchArgs.add(new Object[]{3});userService.batchUpdate(batchArgs);4 事务
4.1 概念
事务是数据库操作最基本单元逻辑上一组操作序列要么都执行成功如果有一个失败所有操作都失败。
4.2 四大特性
原子性事务中的所有操作要么全部成功要么全部失败。一致性事务必须使数据库从一个一致性状态变换到另一个一致性状态也就是说一个事务执行之前和执行之后都必须处于一致性状态。隔离性多个并发事务之间要相不影响。持久性 事务一旦提交那么对数据库中的数据的改变就是永久性的。
4.3 Spring 事务管理
4.3.1 概述
一般情况下事务添加到 JavaEE 三层结构里面 Service 层业务逻辑层底层使用 的是AOP 原理。
4.3.2 两种方式
编程式事务管理声明式事务管理一般使用这种方式 基于注解的方式一般使用这种方式基于xml配置文件的方式
4.3.3 Spring 事务管理 API
Spring中提供了PlatformTransactionManager接口代表事务管理器这个接口针对不同的框架提供不同的实现类。
4.3.4 注解声明式事务管理
1、在 spring 配置文件配置事务管理器
!--创建事务管理器--
bean idtransactionManager classorg.springframework.jdbc.datasource.DataSourceTransactionManager!--注入数据源--property namedataSource refdataSource/property
/bean 2、在 spring 配置文件开启事务注解 1在 spring 配置文件引入名称空间 tx
beans xmlnshttp://www.springframework.org/schema/beans xmlns:xsihttp://www.w3.org/2001/XMLSchema-instance xmlns:contexthttp://www.springframework.org/schema/context xmlns:aophttp://www.springframework.org/schema/aop xmlns:txhttp://www.springframework.org/schema/tx xsi:schemaLocationhttp://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 http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd 2开启事务注解
!--开启事务注解--
tx:annotation-driven transactionmanagertransactionManager/tx:annotation-driven 3、在 service 类上面或者 service 类里面方法上面添加事务注解Transactional 1这个注解可以添加到类上面也可以添加方法上面 2如果把这个注解添加类上面这个类里面所有的方法都添加事务 3如果把这个注解添加方法上面为这个方法添加事务
Service
Transactional
public class UserService {}4.3.5 声明式事务管理参数配置
4.3.5.1 Transactional中的参数 4.3.5.2 propagation事务传播行为
Spring框架事务传播行为有7种其中最常用的是REQUIRED和REQUIRES_NEW默认情况为Propagation.REQUIRED
4.3.5.3 ioslation事务隔离级别
1事务有特性成为隔离性多事务操作之间不会产生影响。不考虑隔离性产生很多问题 2有三个读问题脏读、不可重复读、虚幻读 3脏读一个未提交事务读取到另一个未提交事务的数据
4不可重复读一个未提交事务读取到另一提交事务修改数据
5虚读一个未提交事务读取到另一提交事务添加数据 6解决通过设置事务隔离级别解决读问题
4.3.5.4 timeout超时时间
一旦超出给定的时间不提交事务就会自动回滚。默认值为-1表示不会自动进行回滚。
4.3.5.5 readOnly是否只读
读查询操作写添加修改删除操作readOnly 默认值 false表示可以查询可以添加修改删除操作设置 readOnly 值是 true设置成 true 之后只能查询
4.3.5.6 rollbackFor回滚
设置出现哪些异常进行事务回滚默认为空
4.3.5.7 noRollbackFor不回滚
设置出现哪些异常不进行事务回滚
4.3.6 XML 声明式事务管理
在 spring 配置文件中进行配置 第一步 配置事务管理器第二步 配置通知第三步 配置切入点和切面
!--1 创建事务管理器--
bean idtransactionManager
classorg.springframework.jdbc.datasource.DataSourceTransactionManager!--注入数据源--property namedataSource refdataSource/property
/bean
!--2 配置通知-- tx:advice idtxadvice!--配置事务参数--tx:attributes!--指定哪种规则的方法上面添加事务--tx:method nameaccountMoney propagationREQUIRED/!--tx:method nameaccount*/--/tx:attributes
/tx:advice
!--3 配置切入点和切面-- aop:config!--配置切入点--aop:pointcut idpt expressionexecution(* com.atguigu.spring5.service.UserService.*(..))/!--配置切面--aop:advisor advice-reftxadvice pointcut-refpt/
/aop:config4.3.7 完全注解声明式事务管理
创建配置类使用配置类替代 xml 配置文件
Configuration //配置类
ComponentScan(basePackages com.atguigu) //组件扫描
EnableTransactionManagement //开启事务
public class TxConfig {//创建数据库连接池Beanpublic DruidDataSource getDruidDataSource() {DruidDataSource dataSource new DruidDataSource();dataSource.setDriverClassName(com.mysql.jdbc.Driver);dataSource.setUrl(jdbc:mysql:///user_db);dataSource.setUsername(root);dataSource.setPassword(root);return dataSource;}//创建 JdbcTemplate 对象Beanpublic JdbcTemplate getJdbcTemplate(DataSource dataSource) {//到 ioc 容器中根据类型找到 dataSourceJdbcTemplate jdbcTemplate new JdbcTemplate();//注入 dataSourcejdbcTemplate.setDataSource(dataSource);return jdbcTemplate;}//创建事务管理器Beanpublic DataSourceTransactionManager
getDataSourceTransactionManager(DataSource dataSource) {DataSourceTransactionManager transactionManager new
DataSourceTransactionManager();transactionManager.setDataSource(dataSource);return transactionManager;} }测试 AnnotationConfigApplicationContext context new AnnotationConfigApplicationContext(TxConfig.class);AccountService accountService con.getBean(accountService, AccountService.class);accountService.account();5 Spring5 框架新功能
整个 Spring5 框架的代码基于 Java8运行时兼容 JDK9许多不建议使用的类和方 法在代码库中删除Spring 5.0 框架自带了通用的日志封装 Spring5 已经移除 Log4jConfigListener官方建议使用 Log4j2Spring5 框架整合 Log4j2
5.1 日志功能使用步骤
第一步 引入 jar 包 第二步 创建 log4j2.xml 配置文件
?xml version1.0 encodingUTF-8?
!--日志级别以及优先级排序: OFF FATAL ERROR WARN INFO DEBUG TRACE
ALL --
!--Configuration 后面的 status 用于设置 log4j2 自身内部的信息输出可以不设置
当设置成 trace 时可以看到 log4j2 内部各种详细输出--configuration statusINFO!--先定义所有的 appender--appenders!--输出日志信息到控制台--console nameConsole targetSYSTEM_OUT!--控制日志输出的格式--PatternLayout pattern%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-
5level %logger{36} - %msg%n//console/appenders!--然后定义 logger只有定义 logger 并引入的 appenderappender 才会生效--!--root用于指定项目的根日志如果没有单独指定 Logger则会使用 root 作为
默认的日志输出--loggersroot levelinfoappender-ref refConsole//root/loggers
/configuration5.2 Spring5 框架核心容器支持Nullable 注解 Nullable 注解可以使用在方法上面属性上面参数上面表示方法返回可以为空属性值可以为空参数值可以为空 注解用在方法上面方法返回值可以为空 注解使用在方法参数里面方法参数可以为空 注解使用在属性上面属性值可以为空 注意这个注解只能起到提示功能。参考文章
5.3 Spring5 核心容器支持函数式风格 GenericApplicationContext
//函数式风格创建对象交给 spring 进行管理
Test
public void testGenericApplicationContext() {//1 创建 GenericApplicationContext 对象GenericApplicationContext context new GenericApplicationContext();//2 调用 context 的方法对象注册context.refresh();context.registerBean(user1,User.class,() - new User());//3 获取在 spring 注册的对象// 如果注册的时候没有指定beanName则获取的时候使用全类名来获取// User user (User)context.getBean(com.atguigu.spring5.test.User);User user (User)context.getBean(user1);System.out.println(user);
}5.4 Spring5 整合 JUnit5
引入 JUnit5 的 jar 包要在Project Structure将其导入。 创建一个测试类在类上添加注解
SpringJUnitConfig(locations classpath:bean1.xml) // locations指向配置文件classpath表示src的路径
public class TestJunit5 {// 自动注入属性这里不需要使用读取xml然后使用getBean()获取对象Autowiredpublic AccountService accountService;Testpublic void test(){// 直接使用属性即可accountService.account();}// 之前的写法做对比Testpublic void test1() {ClassPathXmlApplicationContext con new ClassPathXmlApplicationContext(bean1.xml);AccountService accountService con.getBean(accountService, AccountService.class);accountService.account();}
}
