Spring学习笔记——第三天

最新推荐文章于 2024-06-11 17:41:16 发布

weixin_43829407

最新推荐文章于 2024-06-11 17:41:16 发布

阅读量173

点赞数

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/weixin_43829407/article/details/106593055

版权

spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Spring学习打卡

Spring学习笔记---第三天
Spring笔记第三天

Spring学习笔记—第三天

Spring笔记第三天

Spring动态代理原理

问题：为什么通过原始类的ID获取到的是代理类的对象？

1.JDK实现动态代理（基于接口）

ClassLoader: 类加载器
在这里插入图片描述

InterFaces：         获取与原始类相同的接口
InvocationHandler：  额外功能
//底层创建代理对象
Proxy.newProxyInstance(ClassLoader,InterFaces, InvocationHandler);

package com.baizhi.原理;

import org.junit.Test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class TestJDK {

    @Test
    public   void   testJDK(){
        final UserService userService=new  UserServiceImpl();
        //获取到原始类实现的接口
        Class<?>[] interfaces = userService.getClass().getInterfaces();
        //创建额外功能
        InvocationHandler invocationHandler = new InvocationHandler() {
            //返回值 Object   原始方法的返回值
            @Override         //原始类对象       原始方法           原始方法的参数
            public Object invoke(Object target, Method method, Object[] args) throws Throwable {
                System.out.println("原始方法执行之前执行的功能");
                //调用原始方法  原始方法的返回值
                Object ret = method.invoke(userService, args);
                System.out.println("原始方法执行之后执行的功能");
                return ret;
            }
        };
        //创建动态代理对象             //借类加载器          //相同的接口    //额外功能
        UserService  proxy=(UserService) Proxy.newProxyInstance(TestJDK.class.getClassLoader(), interfaces, invocationHandler);
        proxy.register();
    }
}

2.CGLIB实现动态代理（基于父子类继承关系）

package com.baizhi.原理;

import org.junit.Test;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;

import java.lang.reflect.Method;

public class TestCGLIB {
    @Test
    public   void   testCglib(){
        //原始类对象
        final UserService userService= new  UserServiceImpl();
        //额外功能
        InvocationHandler invocationHandler = new InvocationHandler() {
            /*
             * 返回值 代表调用原始方法的返回值
             *
             * */
            @Override           //原始类对象  原始方法          调用原始方法的参数
            public Object invoke(Object o, Method method, Object[] args) throws Throwable {
                System.out.println("原始方法执行之前执行");
                //调用原始方法
                Object ret = method.invoke(userService, args);
                System.out.println("原始方法执行之后执行");
                return ret;
            }
        };
        //创建enhancer对象
        Enhancer enhancer = new Enhancer();
        //设置类加载器
        enhancer.setClassLoader(TestCGLIB.class.getClassLoader());
        //把原始类作为父类  保证原始类与代理类拥有相同的方法
        enhancer.setSuperclass(userService.getClass());
        //设置额外功能
        enhancer.setCallback(invocationHandler);
        //创建代理对象
        UserServiceImpl userService1 =(UserServiceImpl)enhancer.create();
        userService1.register();
    }
}

Spring默认的动态代理方式： JDK动态代理

proxy-target-class=“false” 默认值为false JDK动态代理

“true” 默认值为true CGLIB代理
在这里插入图片描述

SM整合（Spring+Mybatis）

回顾mybatis开发步骤：

1.建表

2.写实体

3.定义DAO接口

4.Mapper文件实现DAO接口

5.API测试

开发流程：

环境搭建：

1.引入相关依赖

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.11.1</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.5</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>

<dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.2.8</version>
</dependency>
<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
      <groupId>org.springframework</groupId>
     <artifactId>spring-context-support</artifactId>
     <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-jdbc</artifactId>
     <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aop</artifactId>
     <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-beans</artifactId>
     <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-expression</artifactId>
     <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aspects</artifactId>
     <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-tx</artifactId>
     <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-web</artifactId>
     <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis-spring</artifactId>
     <version>1.3.1</version>
</dependency>
<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.40</version>
</dependency>
<dependency>
     <groupId>commons-dbcp</groupId>
     <artifactId>commons-dbcp</artifactId>
     <version>1.4</version>
</dependency>
<dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <version>4.12</version>
</dependency>

2.引入log4j.properties配置文件

3.引入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"
       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:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!--配置数据源                     使用DBCP连接池     -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <!--连接数据库的相关参数-->
        <property name="driverClassName"  value="${driver}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${name}"></property>
        <property name="password" value="${password}"></property>
    </bean>

    <!--自动创建SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--构建SqlSessionFactory需要依赖数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!--起别名  该包下所有的类自动起别名  默认别名是该类的类名-->
        <property name="typeAliasesPackage">
            <value>com.baizhi.entity</value>
        </property>
        <!--Mapper文件注册-->
        <property name="mapperLocations">
            <list>   <!--给com/baizhi/dao包下的以Mapper.xml结尾的文件自动进行注册-->
                <value>com/baizhi/dao/*Mapper.xml</value>
            </list>
        </property>
    </bean>
    <!--自动构建DAO的实现类对象-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--告知Spring  给com.baizhi.dao包下的所有的接口构建DAO的实现类对象-->
        <property name="basePackage">
            <value>com.baizhi.dao</value>
        </property>
    </bean>
</beans>

开发步骤：

1.建表

2.写实体

3.定义DAO接口

4.Mapper文件实现DAO接口

5.配置Spring的配置文件

6.API测试

通过接口名称首字母小写获取实现类对象

Spring声明式事务

注意：Spring提供小的事务仅供测试使用

回顾：

1.事务是什么？

保证一组DAO操作一起成功，一起失败

2.事务应用在哪一层？
Service层

3.如何控制事务？

JDBC：

connection.setAutoCommit(false);

connection.commit();

connection.rollback();

Mybatis:

sqlSession.commit();

sqlSession.rollback();

Spring事务开发步骤

思路：把事务划分为额外功能，通过动态代理的开发步骤，把事务添加到对应的事务

1书写原始类

2.配置原始类的相关信息

3.书写额外功能类

在这里插入图片描述

4.定义切入点

5.组装切面
在这里插入图片描述

Spring事务属性

1.隔离属性 isolation

脏读: 一个事务读取了另一个事务尚未提交的数据

isolation=“READ_COMMITTED”
解决脏读问题 列锁

重复读：多次读取数据读到的结果不一致

isolation=“REPEATABLE_READ” 不可重复读行锁

幻影读：多次统计的结果不一致

isolation=“SERIALIZABLE” 解决幻影读表锁

安全性： SERIALIZABLE>REPEATABLE_READ>READ_COMMITTED

效率： READ_COMMITTED>REPEATABLE_READ>SERIALIZABLE

实战开发中：

isolation=“DEFAULT” 根据数据库的隔离属性而定

Oracle默认隔离级别：READ_COMMITTED

Mysql默认隔离级别： REPEATABLE_READ

2.传播属性

作用：事务嵌套问题

propagation=“REQUIRED” 外部有事务则融入外部事务中，外部没有事务，则开启新的事务（增删改)

propagation=“SUPPORTS” 外部有事务则融入到外部事务中，外部没有事务，则不开启新的事务 (查询)
在这里插入图片描述

3.只读属性

read-Only 默认值false (增删改)

read-Only 设置为true （查询)

4.超时属性

time-out 默认值 -1 根据数据库的超时属性决定

作用：设置具体等待时长

5.异常属性

默认：对RunTimeException 进行回滚操作

对非RunTimeException 进行提交操作

rollback-for 指定哪些异常（含子类）进行回滚

no-rollback-for 指定哪些异常（含子类）进行提交

总结：

增删改： isolation=“DEFAULT” propagation=“REQUIRED” read-Only =false
time-out =-1 异常属性将来根据需求定

查询： isolation=“DEFAULT” propagation=”SUPPORTS“ read-Only =true
time-out =-1 异常属性将来根据需求定

<?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:tx="http://www.springframework.org/schema/tx"
       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/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--读取小配置文件 并获取其中的连接数据库参数-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!--配置数据源                     使用DBCP连接池     -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <!--连接数据库的相关参数-->
        <property name="driverClassName"  value="${driver}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${name}"></property>
        <property name="password" value="${password}"></property>
    </bean>

    <!--自动创建SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--构建SqlSessionFactory需要依赖数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!--起别名  该包下所有的类自动起别名  默认别名是该类的类名-->
        <property name="typeAliasesPackage">
            <value>com.baizhi.entity</value>
        </property>
        <!--Mapper文件注册-->
        <property name="mapperLocations">
            <list>   <!--给com/baizhi/dao包下的以Mapper.xml结尾的文件自动进行注册-->
                <value>com/baizhi/dao/*Mapper.xml</value>
            </list>
        </property>
    </bean>
    <!--自动构建DAO的实现类对象-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--告知Spring  给com.baizhi.dao包下的所有的接口构建DAO的实现类对象-->
        <property name="basePackage">
            <value>com.baizhi.dao</value>
        </property>
    </bean>

    <!--配置UserServiceImpl的相关信息-->
    <bean id="userService" class="com.baizhi.service.UserServiceImpl">
            <!--属性-->          <!--自动创建好的实现类对象的ID-->
        <property name="userDAO" ref="userDAO"  ></property>
    </bean>

    <!--引入事务额外功能代码-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
         <!--控制事务需要连接  连接需要连接数据库的相关参数  -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--描述事务对应的属性-->
    <tx:advice id="dstm" transaction-manager="transactionManager">
        <tx:attributes>
            <!--对register方法上的事务做对应的描述-->
            <tx:method name="modify*"/>
            <!--除了以modify开头的方法以外采用对应的属性值-->
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <!--定义切入点-->
     <aop:config>
         <!--给com.baizhi.service包下以及子包下的所有方法添加-->
         <aop:pointcut id="pc" expression="execution(* com.baizhi.service..*.*(..))"></aop:pointcut>
         <aop:advisor advice-ref="dstm" pointcut-ref="pc"></aop:advisor>
     </aop:config>
</beans>

weixin_43829407

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring学习笔记——第三天

Spring学习打卡Spring学习笔记---第三天Spring笔记第三天Spring动态代理原理1.JDK实现动态代理（基于接口）2.CGLIB实现动态代理（基于父子类继承关系）SM整合（Spring+Mybatis）Spring声明式事务Spring事务开发步骤Spring事务属性Spring学习笔记—第三天Spring笔记第三天Spring动态代理原理问题：为什么通过原始类的ID获取到的是代理类的对象？1.JDK实现动态代理（基于接口）ClassLoader: 类加载器I
复制链接

扫一扫