07JavaEE第七章spring

Spring 是什么?

Spring 是于 2003 年兴起的一个轻量级的,IOC 和 AOP 的 Java 开发框架，它是为了简化企业级应用开发而生的。

Spring 优点轻量级的

Spring 框架使用的 jar 都比较小，一般在 1M 以下或者几百 kb。Spring 核心功能的所需的 jar 总共在 3M 左右。 Spring 框架运行占用的资源少，运行效率高。

非侵入式

编写一些业务类的时候不需要继承 spring 特定的类，通过配置完成依赖注入后就可以使用，此时，spring 就没有侵入到我业务类的代码里.

IOC

即 Inversion of Control，缩写为 IOC，就是由 Spring IoC 容器管理对象，而非传统实现中由程序代码直接操控.

AOP

通过 Spring 提供的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付在 Spring 中，开发人员可以从繁杂的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

一站式框架

Spring 本身也提供了数据访问功能和 web 功能,以及可以很好的管理其他框架。

Spring体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mlZMdOL0-1647175543431)(C:Users褚哲希AppDataRoamingTyporatypora-user-images1646736349497.png)]

Core Container(核心容器):

Beans: 管理 Beans

Core: Spring 核心

Context: 配置文件

expressionLanguage: SpEL 表达式

AOP(切面编程)

AOP 框架: Aspects

Data Access(数据库整合): JDBC, ORM, OXM, JMS, Transaction

Web(MVC Web 开发): Web, Servlet, Portlet, Struts

Test(Junit 整合)

官网地址:https://spring.io/

Spring Hello World 搭建

导入jar

开发类

编写配置文件（配置需要spring管理的类）

容器实现类ClassPathXmlApplicationContext(“spring.xml”) 读取spring文件

getBean（“对象名”）

pom.xml


    4.0.0

    com.ffyc
    SpringPro
    1.0
    SpringPro
    war

    
        1.8
        1.8
        5.6.2
    

    
        
        
            org.springframework
            spring-context
            5.2.2.RELEASE
        
    

    
        
            
                org.apache.maven.plugins
                maven-war-plugin
                3.3.0

spring.xml

import com.ffyc.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml"); //spring容器
        User user = app.getBean("user",User.class);
        System.out.println(user);
    }
}

IOC(控制反转)

控制反转

以前是正控，在哪用，在哪new

现在是反控同一交给spring，交给spring管理的对象，spring在创建时，就可以为我们的对象添加额外的功能。

读作**“反转控制”(Inverse of Control)更好理解，不是什么技术，而是一种设计思想，就是**将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理。IOC 容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由 ioc 容器进行管理，不需要我们再去手动通过 new 的方式去创建对象，由 ioc 容器直接帮我们组装好，当我们需要使用的时候直接从 ioc 容器中直接获取就可以了。

正控：若要使用某个对象，需要自己去负责对象的创建

反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，

不关心对象的创建过程，也就是把创建对象的控制权反转给了 Spring 框架.

**目的:**降低耦合度

底层实现方式: 解析 xml/扫描注解标签 + 工厂模式 + 反射机制

Spring Bean 管理基于 xml 配置方式

bean 配置需要 spring 管理的类id 生成的对象名

class 全类名

name 对象别名,可以为多个

import com.ffyc.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml"); 
        User user = app.getBean("user1",User.class);
//        User user = app.getBean("user1",User.class);
        System.out.println(user);
    }
}

scope:

singleton(默认值):在 Spring 中只存在一个 bean 实例, 单例模式。

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        User user = app.getBean("user",User.class);
        System.out.println(user); //com.ffyc.spring.model.User@1794d431
        User user1 = app.getBean("user",User.class);
        System.out.println(user1); //com.ffyc.spring.model.User@1794d431
        //说明创建的是一个对象
    }
}

prototype:原型 getBean()的时候都会 new Bean()

package com.ffyc.spring.test;

import com.ffyc.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        User user = app.getBean("user",User.class);
        System.out.println(user); //com.ffyc.spring.model.User@604ed9f0
        User user1 = app.getBean("user",User.class);
        System.out.println(user1); //com.ffyc.spring.model.User@6a4f787b
        //创建两次对象
    }
}

request:每次 http 请求都会创建一个 bean, 仅用于 WebApplicationContext环境

session:同一个 http session 共享一个 Bean, 不同 Session 使用不同的 Bean, 使用环境同上

Xml 配置方式依赖注入【DI：Dependency Injection】

指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设置给该对象。

实现 IOC 需要 DI 做支持

注入的方式：

set 方法注入

public class UserService {
    UserDao userDao; //注入
    public void save(){
       userDao.save();
    }
}

public class User {
    private int num;
    private String name;

    public User() {
        System.out.println("User无参构造方法");
    }

    public User(int num, String name) {
        System.out.println("User有参构造方法");
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "num=" + num +
                ", name='" + name + ''' +
                '}';
    }
}

构造方法注入

xml 方式配置

package com.ffyc.spring.service;

import com.ffyc.spring.dao.UserDao;

public class UserService {
    //现在方式改变了，只需要定义即可，在创建UserService的同时，会将UserDao对象注入
    UserDao userDao; //注入

    public void save(){
        userDao.save();
    }

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

package com.ffyc.spring.dao;

public class UserDao {
    public void save(){
        System.out.println("保存用户");
    }
}

注解方式实现注解开发准备工作

注解需要的 jar 包注解功能封装在 AOP 包中，导入 Spring aop jar 包即可

开启注解扫描

注解创建对象

@Component(value=“user”)等于

@Service

@Repository

以上注解都可以实现创建对象功能，只是为了后续扩展功能，在不同的层使用不同的注解标记

@Scope(value=“prototype”) 原型

@Scope(value=“ singleton ”) 单例

注解方式注入属性【DI：Dependency Injection】

@Autowired

@Autowired 是 Spring 提供的注解,可以写在字段和 setter 方法上。如果写在字段上，那么就不需要再写 setter 方法。默认情况下它要求依赖对象必须存在，如果允许 null 值，可以设置它的 required 属性为 false。

byType 自动注入

该注解默认使用按类型自动装配 Bean 的方式。

byName 自动注入

如果我们想使用按照名称（byName）来装配，可以结合@Qualifier 注解一起使用。

需要在引用属性上联合使用注解@Autowired 与@Qualifier。@Qualifier 的value 属性用于指定要匹配的 Bean 的 id 值。

JDK 注解@Resource 自动注入

Spring 提供了对 jdk 中@Resource 注解的支持。@Resource 注解既可以按名称匹配 Bean，也可以按类型匹配 Bean。默认按照 ByName 自动注入

byName 注入引用类型属性

@Resource 注解指定其 name 属性，则 name 的值即为按照名称进行匹配的 Bean 的 id。

注解实现方式

spring.xml

package com.ffyc.spring.model;

import org.springframework.stereotype.Component;

//@Component(value = "student")等同于
//等于配置spring扫描此类时，解析注解标签，功能与xml配置一样的
@Component(value = "student")
public class Student {
    private int num;
    private String name;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.ffyc.spring.dao;
import org.springframework.stereotype.Repository;
//@Repository(value="userDao")
@Repository
public class StudentDao {
    public void save(){
        System.out.println("保存学生");
    }
}

package com.ffyc.spring.service;

import com.ffyc.spring.dao.StudentDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service(value = "studentService")
public class StudentService {
    
    @Autowired
    StudentDao studentDao;

    public void save(){
        studentDao.save();
    }
}

package com.ffyc.spring.test;

import com.ffyc.spring.model.Student;
import com.ffyc.spring.service.StudentService;
import com.ffyc.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test3 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        StudentService studentService = app.getBean("studentService",StudentService.class);
        studentService.save();
    }
}

Spring JDBC

Spring 是个一站式框架：Spring 自身也提供了控制层的 SpringMVC 和持久层的 Spring JdbcTemplate。

开发步骤

下载 Spring JdbcTemplate 的 jar 包：

 
 
    org.springframework 
    spring-jdbc 
    5.2.2.RELEASE 
 
 
 
    com.alibaba 
    druid 
    1.1.10

导入属性文件：

管理数据源对象：

spring 管理与数据库链接 (数据源)

在配置文件中创建 JdbcTemplate ：

在类中获得 JdbcTemplate 对象，就可以直接使用。 JdbcTemplate 中常用的方法

execute：无返回值，可执行 ddl，增删改语句

update：执行新增、修改、删除语句；

queryForXXX：执行查询相关语句；

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

//@Component(value = "student")等同于
//等于配置spring扫描此类时，解析注解标签，功能与xml配置一样的
@Component(value = "student")
@Scope(value = "prototype")
public class Student {
    private int num;
    private String name;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.ffyc.spring.dao;

import com.ffyc.spring.model.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

//@Repository 可直接通过类名调用
@Repository(value="studentDao")
public class StudentDao {
    @Autowired
    JdbcTemplate jdbcTemplate;

    public void save(){
        System.out.println("保存学生");
        //execute(String sql)用于执行ddl语句
        //jdbcTemplate.execute("create table test(id int,name varchar(20))");
        //jdbcTemplate.update("insert into student(num,name,gender)values(?,?,?)",200,"zhang","男");
        //jdbcTemplate.update("delete from student where id = ?", 26);

        List list = jdbcTemplate.query("select * from student where gender=?",
                new RowMapper() {
                    @Override
                    public Student mapRow(ResultSet resultSet, int i) throws SQLException {
                        Student student = new Student();
                        student.setNum(resultSet.getInt("num"));
                        student.setName(resultSet.getString("name"));
                        return student;
                    }
                }
                ,"男");
    }
}

package com.ffyc.spring.service;

import com.ffyc.spring.dao.StudentDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service(value = "studentService")
public class StudentService {
    
    @Autowired
//    @Resource(name = "studentDao")
    StudentDao studentDao;

    public void save(){
        studentDao.save();
    }
}

package com.ffyc.spring.test;

import com.ffyc.spring.model.Student;
import com.ffyc.spring.service.StudentService;
import com.ffyc.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test3 {
    public static void main(String[] args) {

        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        
        StudentService studentService = app.getBean("studentService",StudentService.class);
        studentService.save();
    }
}

spring.xml

不使用 AOP 的开发方式

先定义好接口与一个实现类，该实现类中除了要实现接口中的方法外，还要再写两个非业务方法。非业务方法也称为交叉业务逻辑：

➢ doTransaction()：用于事务处理

➢ doLog()：用于日志处理

然后，再使接口方法调用它们。接口方法也称为主业务逻辑。

AOP AOP 概述

AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是 Spring 框架中的一个重要内容。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP、OOP 在字面上虽然非常类似，但却是面向不同领域的两种设计思想。OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。而 AOP 则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设计思想在目标上有着本质的差异。

面向切面编程的好处就是: 减少重复,专注业务；

注意：面向切面编程只是面向对象编程的一种补充。

核心原理：

使用动态代理的方式在执行方法前后或者出现异常的时候做加入相关的逻辑.

使用案例:

事务处理：开启事务，关闭事务，出现异常后回滚事务

权限判断：在执行方法前，判断是否具有权限

日志：在执行前进行日志处理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x8Y60FHB-1647175543435)(E:学习笔记JavaEE图AOP使用案例.png)]

AOP 的基本概念

**连接点（Joinpoint）：**类中可以被增强的方法，这个方法就被称为连接点。

**切入点（pointcut）：**类中有很多方法可以被增强，但实际中只有 add 和 update被增了，那么 add 和 update方法就被称为切入点（实际实现的连接点）。

通知(Advice): 通知是指一个切面在特定的连接点要做的事情(增强的功能)。通知分为方法执行前通知，方法执行后通知，环绕通知等。

**切面(Aspect)*把通知添加到切入点的过程叫切面。

目标(Target): 代理的目标对象(要增强的类) 。

代理(Proxy): 向目标对象应用通知之后创建的代理对象。

springAOP 实现

对于 AOP 这种编程思想，很多框架都进行了实现。Spring 就是其中之一，可以完成面向切面编程。

然而，AspectJ 也实现了 AOP 的功能，AspectJ 是一个基于 Java 语言的 AOP框架，它提供了强大的 AOP 功能,且其实现方式更为简捷，使用更为方便，而且还支持注解式开发。所以，Spring 又将 AspectJ 的对于 AOP 的实现也引入到了自己的框架中。

在 Spring 中使用 AOP 开发时，一般使用 AspectJ 的实现方式。 AspectJ 是一个优秀面向切面的框架，它扩展了 Java 语言，提供了强大的切面实现。

AspectJ 中常用的通知有五种类型：

前置通知后置通知环绕通知异常通知最终通知

下载 AOP 相关 jar

 
    org.springframework 
    spring-aspects 
    5.2.2.RELEASE

基于 aspectj 的 xml 配置方式实现

xml配置

package com.ffyc.spring.util;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyUtil {
    
    public void commit(){
        System.out.println("关闭连接，提交事务");
    }

    
    public void saveLog(){
        System.out.println("保存日志");
    }

    
    public void around(ProceedingJoinPoint point){
        System.out.println("保存日志功能");
        try {
            point.proceed(); //调用我们自己的业务代码
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("关闭连接，提价事务功能");
    }

    
    public void exception(Throwable e){
        System.out.println("出异常了："+e.getMessage());
    }
}

package com.ffyc.spring.service;

import com.ffyc.spring.dao.StudentDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service(value = "studentService")
public class StudentService {
    
//    @Autowired
//    @Resource(name = "studentDao")
    @Resource //通过类型查找注入
    StudentDao studentDao;

    public void save(){
//        studentDao.save();
        System.out.println("保存");
        System.out.println(10/0); //异常通知用
    }

    public void delete(){
        System.out.println("删除");
    }
}

package com.ffyc.spring.test;

import com.ffyc.spring.service.StudentService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        StudentService studentService = app.getBean("studentService",StudentService.class);
        studentService.save();
        studentService.delete();
    }
}

注解方式

package com.ffyc.spring.util;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyUtil {
    
    //save(String) 仅能调用String类型
    @After("execution(* com.ffyc.spring.service.StudentService.save(..))")
    public void commit(){
        System.out.println("关闭连接，提交事务");
    }

    
    //save(..) ..表示可以调用任何类型
    @Before("execution(* com.ffyc.spring.service.StudentService.save(..))")
    public void saveLog(){
        System.out.println("保存日志");
    }

    
    @Around("execution(* com.ffyc.spring.service.StudentService.delete(..))")
    public void around(ProceedingJoinPoint point){
        System.out.println("保存日志功能");
        try {
            point.proceed(); //调用我们自己的业务代码
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("关闭连接，提价事务功能");
    }

    
    @AfterThrowing(value = "execution(* com.ffyc.spring.service.StudentService.delete(..))",throwing = "e")
    public void exception(Throwable e){
        System.out.println("出异常了："+e.getMessage());
    }
}

package com.ffyc.spring.test;

import com.ffyc.spring.service.StudentService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        StudentService studentService = app.getBean("studentService",StudentService.class);
        studentService.save();
        studentService.delete();
    }
}

Spring 事物管理

事物可以看做是由对数据库若干操作组成的一个单元。

我们在开发企业应用时，对于业务人员的一个操作实际是对数据读写的多步操作的结合。由于数据操作在顺序执行的过程中，任何一步操作都有可能发生异常，异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前成功操作数据的并不可靠，需要在这种情况下进行回退。

事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都必须成功执行，只要有发生异常就回退到事务开始未进行操作的状态,这些操作要么都完成，要么都取消，从而保证数据满足一致性的要求Spring 中的事务管理分为两种形式,一种是编程式事务,一种是声明式事务。

编程式事务

在项目中很少使用 , 这种方式需要注入一个事务管理对象 TransactionTemplate ,然后在我们代码中需要提交事务或回滚事务时自己写代码实现。

需要在业务代码中,显示的提交事务 ,使用TransactionTemplate transactionTemplate;
transactionTemplate.execute() 在此方法中执行业务代码

声明式事务

声明式事物就是使用注解标签对需要添加事务的方法进行声明即可,这样次方法就会在事务管理中执行

管理建立在 AOP 基础上，本质是对方法前后进行拦截，所以声明式事务是方法级别的。

Spring 声明式事物管理方式有两种：

基于 xml 配置

基于注解实现

Spring 事物管理 APIPlatformTransactionManager 事物管理器接口

Spring 针对不同的 dao 框架，提供了不同的实现类,Jdbc,mybatis 事物管理实现类是 DataSourceTransactionManager.

配置事物管理器

注解方式

在 service 中控制事务

@Service(value=“userservice”)

@Transactional(propagation=Propagation.REQUIRED)

声明式事务不生效的场景

调用同一个类中被@Transactional 修饰的方法

注解@Transactional 所在类非spring容器管理的bean 自己new的，没有添加注解标签@Service

异常被 catch 捕获导致@Transactional 失效

数据库引擎不支持事务 mysql有好几种存储引擎，mysql中只有innoDB支持事物

@Transactional 注解属性 propagation 设置错误

spring中是如何事物管理的

声明式事务

编程式事物

事务管理实现原理： aop面向切面，不用在再业务代码中显示的提交，就可以实现事务的增强功能

aop实现的原理：动态代理

动态代理有哪几种：jdk代理、cglib代理

spring中的事物传播行为事务传播行为

传播，也就是至少两个方法之间在相互调用。

事务是数据库的行为，事务传播行为是spring框架自己添加的功能

即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。

事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。事务传播行为是 Spring 框架独有的事务增强特性，他不属于的事务实际提供方数据库行为.

例如：methodA 事务方法调用 methodB 事务方法时，methodB 是继续在调用者 methodA 的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB 的事务传播行为决定的。

spring中提供了七种传播行为

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

@Repository
public class LogDao {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional
    public void addlog(){
        jdbcTemplate.update("intsert into log(content)values ('添加账号')");
    }
}

public class Test2 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        BankService bankService = app.getBean("bankService",BankService.class);
        bankService.addAccount();
    }
}

1.PROPAGATION_REQUIRED

默认的，如果有事务就加入到当前事务中执行

指定的方法必须在事务内执行,若当前存在事务,加入到当前事务中,若当前没有事务,则创建一个新事务,这种传播行为是最常见的,也是 spring 默认的传播行为。

有事务

import com.ffyc.spring.dao.BankDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.swing.plaf.PanelUI;

@Service(value = "bankService")
//@Transactional添加在类的上面,表示此类中所有方法,都在spring事务管理中进行
public class BankService {

    @Autowired
    BankDao bankDao;
    @Autowired
    LogService logService;

    @Transactional(propagation = Propagation.REQUIRED)
    public  void zhuanzhang(){
        bankDao.jian();
        bankDao.jia();
    }

    
    @Transactional(propagation = Propagation.REQUIRED) //默认枚举类型
    public void addAccount(){
        logService.addLog();
        System.out.println(10/0);
        bankDao.addAccount();
    }


}

package com.ffyc.spring.service;

import com.ffyc.spring.dao.LogDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class LogService {
    @Autowired
    LogDao logDao;
    
    @Transactional(propagation = Propagation.REQUIRED)
    public void addLog(){
        logDao.addlog(); //事务默认提交
    }
}

无事务

@Service(value = "bankService")
//@Transactional添加在类的上面,表示此类中所有方法,都在spring事务管理中进行
public class BankService {

    @Autowired
    BankDao bankDao;
    @Autowired
    LogService logService;

    @Transactional(propagation = Propagation.REQUIRED)
    public  void zhuanzhang(){
        bankDao.jian();
        bankDao.jia();
    }

    
    //@Transactional(propagation = Propagation.REQUIRED) //默认枚举类型
    public void addAccount(){
        logService.addLog();
//        System.out.println(10/0);
        bankDao.addAccount();
    }
}

@Service
public class LogService {
    @Autowired
    LogDao logDao;
    
    @Transactional(propagation = Propagation.REQUIRED)
    public void addLog(){
        logDao.addlog(); //事务默认提交
    }
}

2.PROPAGATION_SUPPORTS

如果有事务就加入到当前事务中执行，如果没有事务也就没有事务

支持当前事务，如果当前没有事务，就以非事务方式执行。

有事务

@Service(value = "bankService")
public class BankService {

    @Autowired
    BankDao bankDao;
    @Autowired
    LogService logService;

    @Transactional(propagation = Propagation.REQUIRED)
    public  void zhuanzhang(){
        bankDao.jian();
        bankDao.jia();
    }

    @Transactional(propagation = Propagation.REQUIRED) //默认枚举类型
    public void addAccount(){
        logService.addLog(); 
        bankDao.addAccount();
    }
}

@Service
public class LogService {
    @Autowired
    LogDao logDao;

    
    @Transactional(propagation = Propagation.SUPPORTS)
    public void addLog(){
        logDao.addlog(); //事务默认提交
        System.out.println(10/0);
    }
}

无事务

@Service(value = "bankService")
public class BankService {

    @Autowired
    BankDao bankDao;
    @Autowired
    LogService logService;

    @Transactional(propagation = Propagation.REQUIRED)
    public  void zhuanzhang(){
        bankDao.jian();
        bankDao.jia();
    }

    //@Transactional(propagation = Propagation.REQUIRED) //默认枚举类型
    public void addAccount(){
        logService.addLog(); 
        bankDao.addAccount();
    }
}

@Service
public class LogService {
    @Autowired
    LogDao logDao;
    
    @Transactional(propagation = Propagation.SUPPORTS)
    public void addLog(){
        logDao.addlog(); //事务默认提交
        System.out.println(10/0);
    }
}

3.PROPAGATION_REQUIRES_NEW

如果有事务就会挂起当前事务，自己新开启一个独立的事务运行，如果没有事务也会开启一个独立的事务运行。

总是新建一个事务，如果当前存在事务，把当前事务挂起,直到新建的事务结束。

4.PROPAGATION_NOT_SUPPORTED

不支持事务，即使有事务，也会挂起

5.PROPAGATION_NEVER

Spring 集成 Mybatis

spring框架就像是一个管家，凭借着IOC功能（IOC创建管理对象），可以非常轻松来集成其他框架。

搭建SSM框架

早期SSM指的是spring(管理) struts2(web层 servlet) mybatis(jdbc dao层)，再之前还有一个SSH指的是spring struts2 hibernate

现在的SSM指的是spring、springMVC（spring体系中的一部分）、mybatis

导入 mybatis jar 包

Spring 结合 mybatis 插件包

 
    org.mybatis 
    mybatis-spring
    1.3.1

配置 sqlSessionFactory

spring.xml

mybatis.xml

db.xml

4.spring中配置mybatis

spring_mybatis.xml

5.测试ssm

public class Test {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        LoginService loginService = app.getBean("loginService",LoginService.class);
        User user = new User();
             user.setAccount("admin");
             user.setPassword("1111");
           User u = loginService.login(user);
        System.out.println(u);
    }
}

.org/schema/aop"
xmlns:tx=“http://www.springframework.org/schema/tx”
xsi:schemaLocation=“http://www.springframework.org/schema/beans
https://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”>

```

5.测试ssm

public class Test {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        LoginService loginService = app.getBean("loginService",LoginService.class);
        User user = new User();
             user.setAccount("admin");
             user.setPassword("1111");
           User u = loginService.login(user);
        System.out.println(u);
    }
}

07JavaEE第七章spring

Java相关栏目本月热门文章