文章目录
Spring概述
Spring是轻量级的开源JavaEE框架,可以解决企业应用开发的复杂性。Spring有两个核心部分,即IOC和AOP。
- IOC:控制反转,把创建对象的过程交给Spring进行管理。
- AOP:面向切面编程,不修改源代码的前提下进行功能增强。
Spring框架的特点:
- 方便解耦,简化开发。利用IOC可以降低硬编码程序的耦合度。
- 支持AOP编程。
- 方便程序的测试,Spring支持JUint4,通过注解即可进行测试。
- 方便集成各种优秀框架,例如MyBatis等。
- 降低JavaEE各类API使用难度。
- 方便进行事务操作。
Spring5 Demo
五个基本jar包:
- commons-logging-1.2.jar:日志
- spring-beans-5.2.7.RELEASE.jar
- spring-context-5.2.7.RELEASE.jar
- spring-core-5.2.7.RELEASE.jar
- spring-expression-5.2.7.RELEASE.jar
1、创建对象类
public class User {
public void add(){
System.out.println("hello world");
}
}
2、Spring5配置文件
<?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="user" class="spring5.User">
</bean>
</beans>
3、测试类(通过Spring5获取对象)
@Test
public void test1(){
//1.加载spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("config/bean1.xml");
//2.获取配置创建的对象,第一个参数是Spring5配置的bean的id,第二个参数是对象的实体类
User user = context.getBean("user", User.class);
user.add();
}
IOC容器
底层原理
IOC是控制反转,把对象的创建和对象之间的调用过程,交给Spring进行管理。使用IOC的目的就是降低程序之间的耦合度。底层三大技术:xml解析、工厂模式、反射。
IOC过程:
第一步,XML配置我呢见,配置创建的对象。
<bean id="dao" class="com.xingyu.UserDao"></bean>
第二步,创建工厂类
public class UserFactory {
public static UserDao getDao() throws Exception{
String classValue = 配置文件中class属性值,即com.xingyu.UserDao;//1.XML解析
Class clazz = Class.forName(classValue);//2.通过反射创建对象
return (UserDao) clazz.newInstance();
}
}
IOC接口
IOC思想基于IOC容器完成,IOC容器底层就是对象工厂。
Spring提供IOC容器实现两种方式(两个接口):
- **BeanFactory:**IOC容器基本实现,是Spring内部使用的接口,一般不提供开发人员进行使用。
- 加载配置文件时不会创建对象,在获取对象或者适用对象时才创建
- **ApplicationContext:**是BeanFactory的子接口,提供更多更强大的功能,一般由开发人员使用。
- 加载配置文件时就会把配置文件中的对象进行创建
- 实现类:
- new FileSystemXmlApplicationContext(磁盘路径)
- new ClassPathXmlApplicationContext(内路径,即src下)
Bean管理指的是两个操作:(1)Spring创建对象 (2)Spirng注入属性
Bean管理操作有两种方式:(1)基于 xml 配置文件方式实现 (2)基于注解方式实现
IOC操作Bean管理(XML)
<bean id="dao" class="com.xingyu.UserDao"></bean>
在 spring 配置文件中,使用 bean标签,标签里面添加对应属性,就可以实现对象创建。在bean标签有很多属性,常用的属性
- id 属性:唯一标识
- class 属性:类全路径(包类路径)
- 创建对象时候,默认是执行无参数构造方法完成对象创建
DI,依赖注入,即注入属性,是在创建对象的前提下完成。基于 xml 方式注入属性:(1)使用 set 方法进行注入;(2)使用有参数构造进行注入;
注入属性——使用set方法进行注入:即在实体类中实现属性set方法,调用此set方法给属性赋值。
实现过程:
第一步、创建类,定义属性和对应的 set 方法
public class Book {
//创建属性
private String bname;
private String bauthor;
//创建属性对应的set方法
public void setBname(String bname) {
this.bname = bname;
}
public void setBauthor(String bauthor) {
this.bauthor = bauthor;
}
}
第二步、在 spring 配置文件配置对象创建,配置属性注入
<bean id="book" class="com.xingyu.entity.Book">
<!--使用property完成属性注入 name:类里面属性名称 value:向属性注入的值
--> <property name="bname" value="易筋经"></property>
<property name="bauthor" value="达摩老祖"></property>
</bean>
注入属性——使用有参数构造进行注入:
实现过程:
第一步、创建类,定义属性,创建属性对应有参数构造方法
第二步、在 spring 配置文件中进行配置
<bean id="orders" class="com.xingyu.entity.Orders">
<constructor-arg name="oname" value="电脑"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>
</bean>
注入属性——给属性注入特殊值:
1、null值:
<property name="address">
<null/>
</property>
2、属性值包含特殊符号,把带特殊符号内容写到CDATA
<property name="address">
<value><![CDATA[<<南京>>]]></value>
</property>
注入属性——外部Bean:
public 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 service和dao对象创建-->
<bean id="userService" class="service.UserService">
<!--注入userDao对象
name属性:类里面属性名称
ref属性:创建userDao对象bean标签id值
-->
<property name="userDao" ref="userDaoImpl"/>
</bean>
<bean id="userDaoImpl" class="dao.UserDaoImpl"/>
注入属性——内部Bean:
在实体类之间表示一对多关系,员工表示所属部门,使用对象类型属性进行表示。
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门,使用对象形式表示
private Dept dept;
...
//get、set
}
<!--内部bean-->
<bean id="emp" class="bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--设置对象类型属性-->
<!--这是内部Bean的方式,使用之前的外部Bean,用ref引入也可以-->
<property name="dept">
<bean id="dept" class="bean.Dept">
<property name="dname" value="安保部"></property>
</bean>
</property>
</bean>
注入属性——级联赋值:
//这种写法,需要在包含dept对象属性的emp类中生成dept的get方法
public Dept getDept() {
return dept;
}
<!--级联赋值-->
<bean id="emp" class="bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
<property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="bean.Dept">
<property name="dname" value="财务部"></property>
</bean>
注入属性——集合属性:
<!--1 集合类型属性注入-->
<bean id="stu" class="collectiontype.Stu">
<!--数组类型属性注入-->
<property name="courses">
<array>
<value>java课程</value>
<value>数据库课程</value>
</array>
</property>
<!--list类型属性注入-->
<property name="list">
<list>
<value>张三</value>
<value>小三</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>
<!--创建多个course对象-->
<bean id="course1" class="collectiontype.Course">
<property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="collectiontype.Course">
<property name="cname" value="MyBatis框架"></property>
</bean>
<!--注入list集合类型,值是对象-->
<property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
</bean>
IOC操作Bean(FactoryBean)
Spring 有两种类型 bean,一种普通 bean,另外一种工厂 bean(FactoryBean)
- 普通 bean:在配置文件中定义 bean 类型就是返回类型
- 工厂 bean:在配置文件定义 bean 类型可以和返回类型不一样
- 第一步 创建类,让这个类作为工厂 bean,实现接口 FactoryBean
- 第二步 实现接口里面的方法,在实现的方法中定义返回的 bean类型
public class MyBean implements FactoryBean<Course> {
//定义返回bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("abc"); return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override public boolean isSingleton() {
return false;
}
}
Bean作用域
在 Spring 里面,默认情况下,bean 是单实例对象
设置单实例还是多实例:
- 在 spring 配置文件 bean标签里面有属性(scope)用于设置单实例还是多实例
- scope 属性值:
- 第一个值默认值,singleton,表示是单实例对象;
- 第二个值 prototype,表示是多实例对象
- request:每次创建对象会放在request域中。(了解)
- session:每次创建对象会放在session域中。(了解)
singleton和 prototype 区别:
- singleton单实例,prototype 多实例
- 设置 scope 值是 singleton时候,加载 spring 配置文件时候就会创建单实例对象,设置 scope 值是 prototype 时候,不是在加载 spring 配置文件时候创建对象,在调用 getBean方法时候创建多实例对象
Bean生命周期
生命周期即从对象创建到对象销毁的过程。
bean 生命周期:
- 通过构造器创建 bean 实例(默认无参数构造、工厂模式)
- 为 bean的属性设置值和对其他 bean引用(调用 set 方法)
- 调用 bean的初始化的方法(需要进行配置初始化的方法)
- bean可以使用了(对象获取到了)
- 当容器关闭时候,调用 bean的销毁的方法(需要进行配置销毁的方法)
<bean id="orders" class="com.atguigu.spring5.bean.Orders" initmethod="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>
bean 的后置处理器,bean 生命周期有七步:
- 通过构造器创建 bean 实例(无参数构造)
- 为 bean的属性设置值和对其他 bean引用(调用 set 方法)
- 把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
- 调用 bean的初始化的方法(需要进行配置初始化的方法)
- 把 bean实例传递 bean后置处理器的方法 postProcessAfterInitialization
- bean可以使用了(对象获取到了)
- 当容器关闭时候,调用 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;
}
}
XML自动装配
根据指定装配规则(属性名称或者属性类型),Spring自动将匹配的属性值进行注入。
bean标签属性autowire,配置自动装配,autowire属性常用两个值:
- byName根据属性名称注入 ,注入值bean的id值和类属性名称一样
- byType根据属性类型注入
1、根据属性名称自动注入:
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
2、根据属性类型自动注入:
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
IOC操作Bean(注解)
- 注解是代码特殊标记,格式:@注解名称(属性名称=属性值, 属性名称=属性值…)
- 使用注解,注解作用在类上面,方法上面,属性上面
- 使用注解目的:简化 xml 配置
Spring 针对 Bean 管理中创建对象提供注解,这四个注解功能是一样的,都可以用来创建 bean实例:
- @Component
- @Service:建议用在Service层
- @Controller:建议用在Web层
- @Repository:建议用在DAO层
基于注解方式实现对象创建:
第一步、引入依赖 spring-aop-5.2.6.RELEASE.jar
第二步、开启组件扫描:
<context:component-scan base-package="com.atguigu"></context:component-scan>
第三步、创建类,在类上面添加创建对象注解(在注解里面value属性值可以省略不写, 默认值是类名称,首字母小写)
@Component(value = "userService") //相当于手动装配的<bean id="userService" class=".."/>
public class UserService {
public void add() {
System.out.println("service add.......");
}
}
开启组件扫描细节配置
<!--示例1 use-default-filters="false" 表示现在不使用默认filter,自己配置filter
context:include-filter ,设置扫描哪些内容
下述表示只扫描带Controller注解的类
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例2 下面配置扫描包所有内容
context:exclude-filter: 设置哪些内容不进行扫描
下述表示不扫描带Controller注解的类
-->
<context:component-scan base-package="com.atguigu">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
注解实现属性注入
1、@Autowired:根据属性类型进行自动装配
- 创建 service 和 dao对象,在 service 和 dao类添加创建对象注解
- 在 service 注入 dao 对象,在 service 类添加 dao类型属性,在属性上面使用注解
@Service
public class UserService {
//定义dao类型属性 //不需要添加set方法 //添加注入属性注解
@Autowired
private UserDao userDao;
public void add() {
System.out.println("service add.......");
userDao.add();
}
}
2、@Qualifier:根据名称进行注入。
这个@Qualifier 注解的使用,和上面@Autowired 一起使用。因为如果存在多个类型相同的属性,根据类型注入会失败;所以也要根据名称注入。
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
3、@Resource:可以根据类型注入,可以根据名称注入
//@Resource无参数时是根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
4、@Value:注入普通类型属性
@Value(value = "abc")
private String name;
完全注解开发:
1、创建配置类,替代 xml 配置文件
@Configuration //作为配置类,替代xml配置文件
@ComponentScan(basePackages = {
"com.atguigu"}) //配置扫描的包
public class SpringConfig {
}
2、编写测试类
@Test
public void testService() {
//加载配置类
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService",UserService.class);
System.out.println(userService); userService.add();
}
AOP
AOP,面向切面编程,利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
通俗地讲:即不通过修改源代码的方式,在主干功能里面添加新功能。
AOP 底层使用动态代理,有两种情况动态代理
- 第一种,有接口情况,使用 JDK 动态代理,属于创建接口实现类代理对象,增强类的方法
- 第二种,没有接口情况,使用 CGLIB 动态代理 ,属于创建子类的代理对象,增强类的方法
AOP操作术语
- 连接点:类里面可以被增强的方法称作连接点
- 切入点:实际被真正增强的方法称作切入点
- 通知(增强):实际增强的逻辑部分称为通知(增强)。通知有多种类型:
- 前置通知:切入点之前执行的增强
- 后置通知:切入后之前执行的增强
- 环绕通知:切入点之前和之后都执行的增强
- 异常通知:出现异常时执行的增强
- 最终通知:类似try-catch-finally中的finally,无论如何都会执行的增强
- 切面:动作,把通知应用到切入点的过程称作切面
AspectJ
Spring框架一般基于AspectJ实现AOP操作。AspectJ 不是 Spring 组成部分,是独立 AOP 框架,一般把 AspectJ 和 Spirng 框架一起使用,进行 AOP操作
基于 AspectJ 实现 AOP 操作:
- 基于 xml 配置文件实现
- 基于注解方式实现(使用)
切入点表达式:
- 切入点表达式作用:知道对哪个类里面的哪个方法进行增强
- 语法结构: execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
- 举例 1:对 com.atguigu.dao.BookDao 类里面的 add 进行增强:execution(* com.atguigu.dao.BookDao.add(…))
- 举例 2:对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强:execution(* com.atguigu.dao.BookDao.* (…))
- 举例 3:对 com.atguigu.dao包里面所有类,类里面所有方法进行增强 execution(* com.atguigu.dao.. (…))
AspectJ 注解
1、创建类,在类里面定义方法
public class User {
public void add() {
System.out.println("add.......");
}
}
2、创建增强类(编写增强逻辑) ,在增强类里面,创建方法,让不同方法代表不同通知类型
public class UserProxy {
public void before() {
//前置通知
System.out.println("before......");
}
public void after() {
//后置通知
System.out.println("before......");
}
...
}
3、进行通知的配置
(1)在 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" xmlns:aop="http://www.springframework.org/schema/aop" 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 http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启注解扫描 -->
<context:component-scan basepackage="com.atguigu.spring5.aopanno"></context:component-scan>
(2)使用注解创建 User 和 UserProxy 对象
@Component
public class User {
public void add() {
System.out.println("add.......");
}
}
@Component
public class UserProxy {
public void before() {
//前置通知
System.out.println("before......");
}
}
(3)在增强类上面添加注解 @Aspect
@Component
@Aspect
public class UserProxy {
public void before() {
//前置通知
System.out.println("before......");
}
}
(4)在 spring 配置文件中开启生成代理对象
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
4、配置不同类型的通知
(1)在增强类的里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置
@Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void before() {
...}
@AfterReturning(value = "execution(*com.atguigu.spring5.aopanno.User.add(..))")
public void afterReturning() {
...}
@After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void after() {
...}
@AfterThrowing(value = "execution(*com.atguigu.spring5.aopanno.User.add(..))")
public void afterThrowing() {
...}
@Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前.........");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后.........");
}
5、相同的切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
}
//前置通知 //@Before注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
System.out.println("before.........");
}
6、有多个增强类对同一个方法进行增强,设置增强类优先级,在增强类上面添加注解 @Order(数字类型值),数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy{
...}
7、完全使用注解开发,创建配置类,不需要创建 xml 配置文件
@Configuration
@ComponentScan(basePackages = {
"com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true) //代替<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
public class ConfigAop {
... }
AspectJ 配置文件
1、创建两个类,增强类和被增强类,创建方法
2、在 spring 配置文件中创建两个类对象
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
3、在 spring 配置文件中配置切入点
<aop:config>
<!--切入点-->
<aop:pointcut id="p" expression="execution(*com.atguigu.spring5.aopxml.Book.buy(..))"/>
<!--配置切面-->
<aop:aspect ref="bookProxy">
<!--增强作用在具体的方法上-->
<aop:before method="before" pointcut-ref="p"/>
</aop:aspect>
</aop:config>
JdbcTemplate
Spring框架对 JDBC 进行封装,使用 JdbcTemplate 方便实现对数据库操作。
1、引入jar包或依赖
2、在 spring 配置文件配置数据库连接池
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="url" value="jdbc:mysql:///user_db" />
<property name="username" value="root" />
<property name="password" value="root" />
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
</bean>
3、配置 JdbcTemplate 对象,注入 DataSource
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入dataSource-->
<property name="dataSource" ref="dataSource"></property>
</bean>
4、创建 service 类,创建 dao类,在 dao注入 jdbcTemplate 对象
记得先添加组件扫描相关配置文件:
<context:component-scan base-package="com.atguigu"></context:component-scan>
jdbcTemplate进行CRUD:
@Service
public class BookService {
//注入dao
@Autowired
private BookDao bookDao;
}
@Repository
public class BookDaoImpl implements BookDao {
//注入JdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
//添加
@Override
public void add(Book book) {
//1 创建sql语句
String sql = "insert into t_book values(?,?,?)";
//2 调用方法实现
Object[] args = {
book.getUserId(), book.getUsername(),book.getUstatus()};
int update = jdbcTemplate.update(sql,args);
System.out.println(update);
}
//更新
@Override
public void updateBook(Book book) {
String sql = "update t_book set username=?,ustatus=? where user_id=?";
Object[] args = {
book.getUsername(), book.getUstatus(),book.getUserId()};
int update = jdbcTemplate.update(sql, args);
System.out.println(update);
}
//删除
@Override public void delete(String id) {
String sql = "delete from t_book where user_id=?";
int update = jdbcTemplate.update(sql, id);
System.out.println(update);
}
//查找特定值,比如数量
@Override
public int selectCount() {
String sql = "select count(*) from t_book";
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
return count;
}
//根据id查询一个
@Override
public Book findBookInfo(String id) {
String sql = "select * from t_book where user_id=?"; //调用方法
Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
return book;
}
//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
}
事务
事务是数据库操作最基本单元,逻辑上一组操作,要么都成功,如果有一个失败所有操作都失败。典型场景:银行转账。
事务四个特性(ACID):原子性、一致性、隔离性、持久性
事务操作过程:
- 开启事务操作
- 进行业务操作
- 未发生异常,提交事务;发生异常,回滚事务
事务添加到 JavaEE 三层结构里面 Service 层(业务逻辑层)
在 Spring 进行事务管理操作,有两种方式:编程式事务管理和声明式事务管理(使用)。
声明式事务管理
在 Spring 进行声明式事务管理,底层使用 AOP原理。
- 基于注解方式(使用)
- 基于 xml 配置文件方式
事务操作:
1、在 spring 配置文件配置事务管理器
<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
2、在 spring 配置文件,开启事务注解
(1)在 spring 配置文件引入名称空间 tx
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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
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 transaction-manager="transactionManager"></tx:annotation-driven>
3、在 service 类上面(或者 service 类里面方法上面)添加事务注解
- @Transactional,这个注解添加到类上面,也可以添加方法上面
- 如果把这个注解添加类上面,这个类里面所有的方法都添加事务
- 如果把这个注解添加方法上面,为这个方法添加事务
@Service
@Transactional(readOnly = false,timeout = -1,propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {
...
}
其中的参数说明:
- propagation:事务传播行为。多事务方法直接进行调用,这个过程中事务是如何进行管理的
- ioslation:事务隔离级别
- timeout:超时时间
- 事务需要在一定时间内进行提交,如果不提交进行回滚
- 默认值是 -1 ,设置时间以秒单位进行计算
- readOnly:是否只读
- 读:查询操作,写:添加修改删除操作
- readOnly 默认值 false,表示可以查询,可以添加修改删除操作
- 设置 readOnly 值是 true,设置成 true 之后,只能查询
- rollbackFor:回滚,设置出现哪些异常进行事务回滚
- noRollbackFor:不回滚。设置出现哪些异常不进行事务回滚
完全注解声明式事务管理
@Configuration //配置类
@ComponentScan(basePackages = "com.xingyu") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
//创建数据库连接池
@Bean
public 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对象
@Bean
public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
//到ioc容器中根据类型找到dataSource
JdbcTemplate jdbcTemplate = new JdbcTemplate();
//注入dataSource
jdbcTemplate.setDataSource(dataSource);
return jdbcTemplate;
}
//创建事务管理器
// @Bean
// public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
// DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
// transactionManager.setDataSource(dataSource);
// return transactionManager;
// }
}
Spring5新特性
1、Spring 5.0 框架自带了通用的日志封装
- Spring5 已经移除 Log4jConfigListener,官方建议使用 Log4j2
- Spring5 框架整合 Log4j2
log4j2.xml配置文件信息:
<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出,可以不设置,当设置成trace时,可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
<!--先定义所有的appender-->
<appenders>
<!--输出日志信息到控制台-->
<console name="Console" target="SYSTEM_OUT">
<!--控制日志输出的格式-->
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
</console>
</appenders>
<!--然后定义logger,只有定义了logger并引入的appender,appender才会生效-->
<!--root:用于指定项目的根日志,如果没有单独指定Logger,则会使用root作为默认的日志输出-->
<loggers>
<root level="info">
<appender-ref ref="Console"/>
</root>
</loggers>
</configuration>
手动在控制台输出日志:
public class UserLog {
private static final Logger log = LoggerFactory.getLogger(UserLog.class);
public static void main(String[] args) {
log.info("hello log4j2");
log.warn("hello log4j2");
}
}
2、Spring5 框架核心容器支持@Nullable 注解
- @Nullable 注解可以使用在方法上面,属性上面,参数上面,表示方法返回可以为空,属性值可以为空,参数值可以为空
- 注解用在方法上面,方法返回值可以为空
- 注解使用在方法参数里面,方法参数可以为空
- 注解使用在属性上面,属性值可以为空
3、Spring5核心容器支持函数式风格GenericApplicationContext
4、Spring5 支持整合 JUnit5
SpringWebflux
SpringWebflux 是 Spring5 添加新的模块,用于 web 开发,功能和 SpringMVC 类似,Webflux 使用响应式编程。
传统 web 框架,比如 SpringMVC,这些基于 Servlet 容器,Webflux 是一种异步非阻塞的框架,异步非阻塞的框架在 Servlet3.1 以后才支持,核心是基于 Reactor 的相关 API 实现的。
- 异步和同步针对调用者,调用者发送请求,如果等着对方回应之后才去做其他事情就是同步,如果发送请求之后不等着对方回应就去做其他事情就是异步
- 阻塞和非阻塞针对被调用者,被调用者受到请求之后,做完请求任务之后才给出反馈就是阻塞,受到请求之后马上给出反馈然后再去做事情就是非阻塞
Webflux 特点:
- 非阻塞式:在有限资源下,提高系统吞吐量和伸缩性,以 Reactor 为基础实现响应式编程
- 函数式编程:Spring5 框架基于 java8,Webflux 使用 Java8 函数式编程方式实现路由请求
响应式编程:
响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流,而相关的计算模型会自动将变化的值通过数据流进行传播。 电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式,而包含公式的单元格的值会依据其他单元格的值的变化而变化。