学习笔记（狂神Spring5 P14-P28）

最新推荐文章于 2024-10-09 11:50:38 发布
最新推荐文章于 2024-10-09 11:50:38 发布
阅读量316 收藏
点赞数
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43003203/article/details/121200969
版权
本文详细介绍了Spring与MyBatis的整合步骤，包括使用注解和XML配置两种方式，以及静态代理和动态代理的实现。此外，还探讨了Spring的AOP（面向切面编程）在方法前、后、环绕增强的应用，并通过实例展示了如何在项目中导入和配置相关依赖。最后，提到了Spring声明式事务管理的概念和配置，以及在实际操作中可能出现的问题和解决方案。
摘要由CSDN通过智能技术生成

上一篇文章笔记的链接

学习笔记源码下载地址

1、使用注解开发

- 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: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">
    <!--    注解驱动-->
    <context:annotation-config/>
    <!--指定注解扫描包-->
    <context:component-scan base-package="包名"/>


</beans>
  • 编写实体类并添加注解
package pojo;

import org.springframework.stereotype.Component;

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
    public String name = "zzzzzz";
}

测试

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.User;

public class MyTest {
    @Test
    public void test() {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) classPathXmlApplicationContext.getBean("user");
        System.out.println(user.name);
    }
}

- 属性如何注入
可以不用提供set方法，直接在直接名上添加@value(“值”)

package pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
    // 相当于配置文件中 <property name="name" value="zzzzzzzzzzz"/>
    @Value("zzzzzz")
    public String name;
}

- 衍生的注解

@Component三个衍生注解（功能一样，目前使用哪一个功能都一样。）

@Controller：web层

@Service：service层

@Repository：dao层

- 自动装配

  • @Autowired:自动装配通过类型，名字否则使用@Qualifier（value=“xxxx”）
  • @Nullable 字段标记了这个注解，说明这个字段可以时null
  • @Resource 自动装配通过名字，类型

- 作用域

@Controller("user")
@Scope("prototype")
public class User {
    @Value("zzzzzzzzz")
    public String name;
}

总结

XML与注解比较

XML可以适用任何场景 ，结构清晰，维护方便

注解不是自己提供的类使用不了，开发简单方便

xml与注解整合开发 ：推荐最佳实践

xml管理Bean

注解完成属性注入

使用过程中， 可以不用扫描，扫描是为了类上的注解

- 基于Java类进行配置

  • 编写一个实体类，Dog
package pojo;

import org.springframework.stereotype.Component;

@Component  //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
    public String name = "dog";
}
  • 编写一个MyConfig配置类
package controller;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import pojo.Dog;

@Configuration  //代表这是一个配置类
public class MyConfig {

    @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
    public Dog dog(){
        return new Dog();
    }

}
  • 测试
    @Test
    public void test1() {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        Dog dog = (Dog) annotationConfigApplicationContext.getBean("dog");
        System.out.println(dog.name);
    }

2、静态代理

角色分析：

抽象角色 : 一般使用接口或者抽象类来实现
真实角色 : 被代理的角色
代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
客户 : 使用代理角色来进行一些操作 .

- 代码实现(demo01)

抽象角色

//抽象角色：租房
public interface Rent {
    public void rent();
}

真实角色

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}

代理角色

//代理角色：中介
public class Proxy implements Rent {
 
    private Host host;
    public Proxy() { }
    public Proxy(Host host) {
        this.host = host;
    }
 
    //租房
    public void rent(){
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

客户

//客户类，一般客户都会去找代理！
public class Client {
    public static void main(String[] args) {
        //房东要租房
        Host host = new Host();
        //中介帮助房东
        Proxy proxy = new Proxy(host);
 
        //你去找中介！
        proxy.rent();
    }
}

结论：

在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式

- 代码实现（demo02）

创建一个抽象角色

//抽象角色：增删改查业务
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

真实对象

//真实对象，完成增删改查操作的人
public class UserServiceImpl implements UserService {
 
    public void add() {
        System.out.println("增加了一个用户");
    }
 
    public void delete() {
        System.out.println("删除了一个用户");
    }
 
    public void update() {
        System.out.println("更新了一个用户");
    }
 
    public void query() {
        System.out.println("查询了一个用户");
    }
}

代理角色

//代理角色，在这里面增加日志的实现
public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;
 
    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }
 
    public void add() {
        log("add");
        userService.add();
    }
 
    public void delete() {
        log("delete");
        userService.delete();
    }
 
    public void update() {
        log("update");
        userService.update();
    }
 
    public void query() {
        log("query");
        userService.query();
    }
 
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
 
}

测试

package demo02;

import org.junit.jupiter.api.Test;

public class Client {

    @Test
    public void test() {
        //真实业务
        UserServiceImpl userService = new UserServiceImpl();
        //代理类
        UserServiceProxy proxy = new UserServiceProxy();
        //使用代理类实现日志功能！
        proxy.setUserService(userService);

        proxy.add();
    }
}

3、动态代理

- 代码实现（demo03）

Rent

package demo03;

//抽象角色：租房
public interface Rent {
    public void rent();
}

Host

package demo03;

//真实角色: 房东，房东要出租房子
public class Host implements Rent {
    public void rent() {
        System.out.println("房屋出租");
    }
}

ProxyInvocationHandler

package demo03;

import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;

import java.lang.reflect.Method;

public class ProxyInvocationHandler implements InvocationHandler {
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(), this);
    }

    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //核心：本质利用反射实现！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }

    //看房
    public void seeHouse() {
        System.out.println("带房客看房");
    }

    //收中介费
    public void fare() {
        System.out.println("收中介费");
    }

}

Client

package demo03;

import org.junit.jupiter.api.Test;

//租客
public class Client {
    @Test
    public void test() {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); //将真实角色放置进去！
        Rent proxy = (Rent) pih.getProxy(); //动态生成对应的代理类！
        proxy.rent();
    }

}

- 代码实现（demo04再demo02的基础上）

ProxyInvocationHandler

package demo04;

import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;

import java.lang.reflect.Method;

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    // proxy : 代理类
    // method : 代理类的调用处理程序的方法对象.
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String methodName){
        System.out.println("执行了"+methodName+"方法");
    }

}

Test

package demo04;

import org.junit.jupiter.api.Test;

public class MyTest {
    @Test
    public void test() {
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        //代理对象的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService); //设置要代理的对象
        UserService proxy = (UserService) pih.getProxy(); //动态生成代理类！
        proxy.delete();
    }
}

4、AOP

- 导入依赖

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

- 方式一：
业务接口和实现类

package service;

public interface UserService {

    public void add();

    public void delete();

    public void update();

    public void search();

}


package service;

public class UserServiceImpl implements UserService{

    @Override
    public void add() {
        System.out.println("增加用户");
    }

    @Override
    public void delete() {
        System.out.println("删除用户");
    }

    @Override
    public void update() {
        System.out.println("更新用户");
    }

    @Override
    public void search() {
        System.out.println("查询用户");
    }
}

一个前置增强 一个后置增强

package log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

    //method : 要执行的目标对象的方法
    //objects : 被调用的方法的参数
    //Object : 目标对象
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
    }
}


package log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    //returnValue 返回值
    //method被调用的方法
    //args 被调用的方法的对象的参数
    //target 被调用的目标对象
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + target.getClass().getName()
                +"的"+method.getName()+"方法,"
                +"返回值："+returnValue);
    }
}

编写配置文件beans.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: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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!--注册bean-->
    <bean id="userService" class="service.UserServiceImpl"/>
    <bean id="log" class="clog.Log"/>
    <bean id="afterLog" class="log.AfterLog"/>
    <!--aop的配置-->
    <aop:config>
        <!--切入点  expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;

public class MyTest {
    @Test
    public void test() {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) classPathXmlApplicationContext.getBean("userService");
        userService.search();
    }
}

- 方法二：
目标业务类不变依旧是userServiceImpl
切入类

package pointcut;

public class DiyPointcut {

    public void before(){
        System.out.println("---------方法执行前---------");
    }
    public void after(){
        System.out.println("---------方法执行后---------");
    }

}

配置beans.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: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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--第二种方式自定义实现-->
    <!--注册bean-->
    <bean id="diy" class="pointcut.DiyPointcut"/>
    <!--aop的配置-->
    <aop:config>
        <!--第二种方式：使用AOP的标签实现-->
        <aop:aspect ref="diy">
            <aop:pointcut id="diyPonitcut" expression="execution(* service.UserServiceImpl.*(..))"/>
            <aop:before pointcut-ref="diyPonitcut" method="before"/>
            <aop:after pointcut-ref="diyPonitcut" method="after"/>
        </aop:aspect>
    </aop:config>
    </beans>

测试

- 方式三：

使用注解实现

注解实现的增强类

package pointcut;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointcut {
    @Before("execution(* service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("---------方法执行前---------");
    }

    @After("execution(* service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("---------方法执行后---------");
    }

    @Around("execution(* service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:" + jp.getSignature());
        //执行目标方法proceed
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

配置beans.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: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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--第三种方式:注解实现-->
    <bean id="annotationPointcut" class="pointcut.AnnotationPointcut"/>
    <aop:aspectj-autoproxy/>

    <!--
        通过aop命名空间的<aop:aspectj-autoproxy/>声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring
        在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy/>隐藏起来了

        <aop:aspectj-autoproxy/>有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为
        <aop:aspectj-autoproxy poxy-target-class="true"/>
        时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。
    -->
</beans>

测试

5、整合MyBatis

回顾

- 导入相关依赖

<dependencies>
        <!--        Spring相关-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.12</version>
        </dependency>

        <!--        spring整合mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <!--        Lombok  减少get/set方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>

        <!--        测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.8.1</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.2</version>
        </dependency>

        <!--        aspectJ AOP 织入器-->
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>

        <!--        mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <!--        mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>


    </dependencies>
    
    <!--配置Maven静态资源过滤问题！-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

- 编写实体类 User

package pojo;


import lombok.Data;

@Data
public class User {
    private int id;  //id
    private String name;   //姓名
    private String pwd;   //密码
}

- 编写mybatis配置文件 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <typeAliases>
        <package name="pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

- 编写实体接口

package mapper;

import pojo.User;

import java.util.List;

public interface UserMapper {
    public List<User> selectUser();
}

- 对应的mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mapper.UserMapper">

    <select id="selectUser" resultType="User">
        select *
        from user
    </select>

</mapper>

- 编写工具类
（可写可不写，后面test中写也可以）

package utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    static SqlSessionFactory sqlSessionFactory = null;
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession();
    }
}

- 测试

import mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import pojo.User;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyTest {

    @Test
/*    public void selectUser() {
        //1.获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //2.执行SQL
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭sqlSession
        sqlSession.close();
    }*/

    public void selectUser() throws IOException {

        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        List<User> userList = mapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }

        sqlSession.close();
    }
}

回顾完后

- 整合方法一：

- 导入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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置数据源：数据源有非常多，可以使用第三方的，也可使使用Spring的-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url"
                  value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--配置SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--关联Mybatis-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!--注册sqlSessionTemplate , 关联sqlSessionFactory-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--利用构造器注入-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <bean id="userMapper" class="mapper.UserDaoImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

这里就可以删除mybatis-config.xml中的除了别名和设置以外的标签了。

- 创建实现类

package mapper;

import org.mybatis.spring.SqlSessionTemplate;
import pojo.User;

import java.util.List;

public class UserMapperImpl implements UserMapper {

    //sqlSession不用我们自己创建了，Spring来管理
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

这里就可以删除以前mybatis中的测试代码了

重新写，如下：

@Test
    public void test2(){
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("beans.xml");
        UserMapper mapper = (UserMapper) classPathXmlApplicationContext.getBean("userMapper");
        List<User> user = mapper.selectUser();
        System.out.println(user);
    }

- 整合方法二：

将上面写的UserDaoImpl修改一下

public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

修改bean的配置

    <bean id="userMapper" class="mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

测试完成。

6、声明式事务

  • 就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用

事务四个属性ACID

原子性（atomicity）

事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用

一致性（consistency）

一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中

隔离性（isolation）

可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏

持久性（durability）

事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中

新建一个整合了mybatis的maven Spring 项目

拷贝上面案例的代码（UserMapper，UserMapper.xml，UserMapperImpl，User，applicationContext.xml，beans.xml，mybatis-config.xml，MyTest）

给UserMapper接口新增两个方法，删除和增加用户

//添加一个用户
int addUser(User user);
 
//根据id删除用户
int deleteUser(int id);

UserMapper.xml

 <insert id="addUser" parameterType="com.kuang.pojo.User">
 insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
 </insert>
 
 <delete id="deleteUser" parameterType="int">
 deletes from user where id = #{id}
</delete>

接口的实现类

public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper {
 
    //增加一些操作
    public List<User> selectUser() {
        User user = new User(4,"小明","123456");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deleteUser(4);
        return mapper.selectUser();
    }
 
    //新增
    public int addUser(User user) {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return mapper.addUser(user);
    }
    //删除
    public int deleteUser(int id) {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return mapper.deleteUser(id);
    }
 
}

测试

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserMapper mapper = (UserMapper) context.getBean("userDao");
    List<User> user = mapper.selectUser();
    System.out.println(user);
}

报错：sql异常，delete写错了
结果 ：插入成功！

Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

将事务管理代码嵌到业务方法中来控制事务的提交和回滚

缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

一般情况下比编程式事务好用。

将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。

将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

使用Spring管理事务，注意头文件的约束导入

<?xml version="1.0" encoding="UTF8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">

JDBC事务

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
 </bean>

<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!--配置哪些方法使用什么样的事务,配置事务的传播特性-->
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" propagation="REQUIRED"/>
        <tx:method name="search*" propagation="REQUIRED"/>
        <tx:method name="get" read-only="true"/>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

添加aop命名空间

       xmlns:aop="http://www.springframework.org/schema/aop"

      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

<!--配置aop织入事务-->
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>

换成正确的SQL再次测试

广而不精zhu小白
关注
专栏目录
狂神说SpringCloud学习笔记
qq_43161404的博客
01-09 2325
前言：B站狂神说Java中SpringBoot笔记，传送门 UP很nice，课程生动形象，欢迎支持。 一、什么是微服务 整体部署：每一个模块的变更很难不影响到其他模块，使得变更周期变得漫长，扩展需要整体扩展，而不能进行部分扩展。 就目前而言，对于微服务，业界并没有一个统一的，标准的定义。 但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它体长将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HT
基于《狂神说Java》SpringCloud --学习笔记
wudidahuanggua的博客
06-21 1034
本笔记仅做学习与复习使用，不存在刻意抄袭。参考于学友菜鸟小杰子。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!
【狂神说java】spring5--学习笔记（持续更新中...）
qq_28288835的博客
04-25 722
Spring是一个轻量级：控制反转（IOC）和面向切面（AOP）的容器框架简介解决企业级开发的复杂性Spring使用的是基本的JavaBean不局限于Javaweb开发，任何Java应用使用基本的JavaBean代替EJBSpring是一个轻量级：控制反转（IOC）和面向切面（AOP）的容器框架开源框架历史2002，推出spring雏形，interface21框架2004年3月24日发布1.0正式版：Spring （以interface21为基础）
狂神说---Spring学习笔记
m0_60139894的博客
12-15 682
狂神说---spring学习笔记
Spring学习笔记-狂神版
myydan的专栏
02-12 1001
1|0前言 Mybatis学完开始学Spring 同样先放上参考文档，现在只是需要短时间之内要过一下基础，等考完研再看要不要深入学习吧。 B站https://www.bilibili.com/video/BV1WE411d7Dv 狂神说Spring01：概述及IOC理论推导https://mp.weixin.qq.com/s/VM6INdNB_hNfXCMq3UZgTQ 狂神说Spring02：快速上手Springhttps://mp.weixin.qq.com/s/Sa39ulmHp...
【狂神】Spring5笔记（二）
qq_62649563的博客
09-01 1211
狂神笔记第二弹 ~ 内容：1、p和c命名空间注入 2、Spring注解开发 3、代理模式
遇见狂神说 Spring 学习笔记（完整笔记+代码）
记录一名在读研究生的学习笔记、感悟、开发产物
01-06 1230
狂神课程 Spring 完整学习笔记（附详细代码和操作）
狂神说-Springcloud笔记
向上的"狼"的博客
07-26 5664
Springcloud
狂神说Spring5学习笔记
Lemonyuki的博客
12-02 1803
文章目录0.DEMO项目1.Spring1.1-简介1.2-优点1.3-组成1.4 拓展2.IOC理论推导2.2-IOC本质3.HelloSpring4.IOC创建对象的方式☆5.Spring配置5.1-别名(就是多一个，名字而已)5.2 Bean的配置5.3-import6.依赖注入(DI)6.1 构造器注入6.2-Set方式(Set方法)注入 【重点】6.3 拓展方式注入6.4 Bean的作用域(单例模式，原型模式等等)7.Bean的自动装配(autowire)7.1 测试7.2 byName自动装配7
狂神说Java --- 记录Spring学习笔记
从零开始的异世界JAVA学习
09-19 1102
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
狂神springcloud学习笔记加代码
03-24
狂神springcloud学习笔记加代码 笔记可以看：https://www.kuangstudy.com/bbs/1374942542566551554#header4 视频链接：https://www.bilibili.com/video/BV1jJ411S7xr
xmljava系统源码-spring-cloud-kuang:狂神springcloud笔记+源码+config
06-06
SpringCloud笔记 1、前言 1.1、回顾 回顾之前的知识 JavaSE 数据库 前端 Servlet Http Mybatis Spring SpringMVC SpringBoot Dubbo、Zookeeper、分布式基础 Maven、Git Ajax、Json ... 串一下自己会的东西 数据库 ...
狂神说Java-Spring学习笔记
05-17
掌握了Spring的基本原理后，还可以进一步学习Spring Boot和Spring Cloud等现代Java开发工具，以提高开发效率和系统的可维护性。此外，对于初学者来说，结合相关的教学视频进行学习，会更容易理解和掌握这些知识点。
狂神Spring5视频MD笔记+源码.7z
01-31
而"Spring学习笔记.md"和"Spring学习目录.md"则可能是作者观看视频后的学习记录，其中可能包含了对Spring关键概念、API使用方法的详细解释和示例，是学习Spring的宝贵资源。 "img"文件夹可能包含了一些图表或示意图...
Spring5学习笔记（狂神）.md
10-26
Spring5学习笔记（狂神）.md
RabbitTemplate与AmqpTemplate：Spring AMQP中的消息传递模板
qq_51321722的博客
10-05 605
是Spring AMQP框架的核心接口，它定义了一套标准的AMQP操作，如发送和接收消息、声明队列和交换机等。这个接口是对AMQP协议的抽象，提供了一种面向对象的方式来操作AMQP协议。它基于RabbitMQ的Java客户端库实现，使得开发者可以通过Spring框架的依赖注入和配置机制来简化与AMQP消息队列系统的交互。而则是Spring AMQP为RabbitMQ提供的一个高级消息操作模板。它实现了接口，并添加了一些针对RabbitMQ的特性和优化。不仅提供了与。
【Spring Security】基于SpringBoot3.3.4版本②如何配置免鉴权Path
Java技术栈，分享不断学习、不断超越、不断积累的历程！
10-03 1296
[【Spring Security】基于SpringBoot3.3.4版本①整合JWT的使用教程](https://blog.csdn.net/friendlytkyj/article/details/142679120) 在这篇文章中，详细演示了使用最新版`Spring Boot`，完成一个微服务开发，并使用`Spring Security`组件完成登录认证，同时整合了`JWT`，使用的`RSA`公私钥签名、验签。 接下来继续讲解下一个业务场景：一个真实场景的微服务，难免会有一些请求`Path`不需要任
springboot实战学习（12）(优化更新用户基本信息接口)(Validation实体参数校验)
最新发布
岁岁岁平安的博客
10-09 671
本篇博客主要是对用户模块的更新用户基本信息接口的代码的一个小优化（实体参数校验）。其中用到了Spring Validation参数校验框架提供的一些注解（如@NotNull、@NotEmpty、@Email、@Validated）去完成实体类对象的参数校验以及完成了功能的测试...
Spring
m0_74728220的博客
10-02 1232
不直接创建对象，而是由容器创建，并设定一个或多个标识，需要的时候通过Bean名字从容器中获取，这看上去是类似于EJB的服务查找，但是Spring真正的核心是对于依赖的处理，使用配置的方式注入依赖。以A、B、C三个类为例，B、C都是单例模式的类，A需要调用B、C类的方法，这样A就和B、C形成了依赖，如果B、C交由容器管理，A虽然和容器产生依赖，但是依赖程度降低了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值