spring(三)

spring(三)

（一）、代理模式

为什么要学习代理模式？ 因为这就是SpringAOP的底层！ 【SpringAOP 和 SpringMVC】

代理模式的分类：

• 静态代理
• 动态代理

什么是代理模式？

**代理模式的定义：**代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。用图表示如下：

为什么要用代理模式？

• **中介隔离作用：**在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
• **开闭原则，增加功能：**代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

.1、静态代理

角色分析：

• 抽象角色 ：一般会使用接口或者抽象类来解决
• 真实角色 ：被代理的角色
• 代理角色 ：代理真实角色 ， 代理真实角色后，我们一般会做一些附属操作
• 客户 ： 访问代理对象的人！

代码步骤：

1. 接口

   //租房
   public interface Rent {
   
       public void rent();
   
   }
   

2. 真实角色

   //房东
   public class Host implements Rent {
   
       public void rent() {
           System.out.println("房东要出租房子！");
       }
   }
   

3. 代理角色

   public class Proxy implements Rent {
   
       private Host host;
   
       public Proxy() {
       }
       public Proxy(Host host) {
           this.host = host;
       }
   
   
       public void rent() {
           seeHouse();
           host.rent();
           hetong();
           fare();
       }
   
       //看房
       public void seeHouse(){
           System.out.println("中介带你看房");
       }
   
       //看房
       public void hetong(){
           System.out.println("签租赁合同");
       }
       //收中介费
       public void fare(){
           System.out.println("收中介费");
       }
   
   }
   

4. 客户端访问代理角色

   public class Client {
       public static void main(String[] args) {
           //房东要租房子
           Host host = new Host();
           //代理，中介帮房东租房子，但是呢？代理角一般会有一些附属操作！
           Proxy proxy = new Proxy(host);
   
           //你不用面对房东，直接找中介租房即可！
           proxy.rent();
       }
   }
   

代理模式的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共也就就交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理！

缺点：

• 一个真实角色就会产生一个代理角色；代码量会翻倍_{开发效率会变低}

2、加深理解

AOP

3、动态代理

即在运行期间根据需要动态创建目标类的代理对象。javaSE API中在java.lang.reflect包中提供了对动态代理的支持的类和接口。

(1)InvocationHandler(Object proxy, Method method, Object[] args)

throws Throwable;提供了对动态代理的支持的类和接口。

(2)Proxy类：提供用于创建动态代理类和实例的静态方法。

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的！
• 动态代理分为两大类 ： 基于接口的动态代理 ， 基于类的动态代理
  • 基于接口 — JDK 动态代理 【我们在这里使用】
  • 基于类 ： cglib
  • java字节码实现 ： javasist

//等我们会用这个类，自动生成代理类！
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);
    }

    //处理代理实例，并返回结果 ：
    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 msg){
        System.out.println("执行了"+msg+"方法");
    }

}

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        pih.setTarget(userService); //设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();

        proxy.query();

    }
}

(二)AOP

1 什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2 Aop在Spring中的作用

提供声明式事务；允许用户自定义切面

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
• 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知 执行的 “地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

（三）使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

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

方式一 ： 使用Spring的API 接口 【主要SpringAPI接口实现】

public class Log implements MethodBeforeAdvice {

​    //method： 要执行的目标对象的方法
​    //args： 参数
​    //target: 目标对象

​    public void before(Method method, Object[] args, Object target) throws Throwable {
​        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
​    }

}

<!--方式一：使用原生Spring API接口 -->
<!--配置aop:需要导入aop的约束-->
<!--<aop:config>-->
    <!--&lt;!&ndash;切入点：expression:表达式，execution(要执行的位置！ * * * * *) &ndash;&gt;-->修饰词 返回值 类 方法名
    <!--<aop:pointcut id="pointcut" expression="execution(* com.qin.service.UserServiceImpl.*(..))"/>-->
    <!--&lt;!&ndash;执行环绕增加！&ndash;&gt;-->
    <!--<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
    <!--<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>-->
<!--</aop:config>-->

public class MyTest {

​    public static void main(String[] args) {
​        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
​        //动态代理代理的是接口：注意点
​        UserService userService = context.getBean("userService",UserService.class);
​        userService.delete();
​    }

}

​

Aspectj切入点语法定义

在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut”切入点”

例如定义切入点表达式 execution (* com.sample.service.impl..***. \***(..))

execution()是最常用的切点函数，其语法如下所示：

整个表达式可以分为五个部分：

1、execution(): 表达式主体。

2、第一个*号：表示返回类型， *号表示所有的类型。

3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。

4、第二个*号：表示类名，*号表示所有的类。

5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数

方式二 ： 自定义来实现AOP 【主要是切面定义】

<!--方式二：自定义类-->
<!--<bean id="diy" class="com.kuang.diy.DiyPointCut"/>-->

<!--<aop:config>-->
    <!--&lt;!&ndash;自定义切面， ref 要引用的类&ndash;&gt;-->
    <!--<aop:aspect ref="diy">-->
        <!--&lt;!&ndash;切入点&ndash;&gt;-->
        <!--<aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>-->
        <!--&lt;!&ndash;通知&ndash;&gt;-->
        <!--<aop:before method="before" pointcut-ref="point"/>-->
        <!--<aop:after method="after" pointcut-ref="point"/>-->
    <!--</aop:aspect>-->
<!--</aop:config>-->

方式三 ： 使用注解实现！

@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
//注解下的包，不要倒错
    @Before("execution(* com.qin.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=====方法执行前======");
    }

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

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点；
    @Around("execution(* com.qin.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Signature signature = jp.getSignature();//获得签名
        System.out.println("signature:"+signature);

        Object proceed = jp.proceed();   //执行方法
        System.out.println("环绕后");

        System.out.println(proceed);
    }


}

<!--注册bean-->
<bean id="userService" class="com.kuang.service.UserServiceImpl"/>
<bean id="log" class="com.qin.log.Log"/>
<bean id="afterLog" class="com.qin.log.AfterLog"/>


<!--方式三-->
<bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
<!--开启注解支持！   JDK(默认 proxy-target-class="false")   cglib（proxy-target-class="true"）-->
<aop:aspectj-autoproxy/>

（四）整合Mybatis

（一）复习mybayis

步骤：

1、导入相关jar包

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <!--Spring操作数据库的话，还需要一个spring-jdbc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.10</version>
    </dependency>
</dependencies>

import lombok.Data;

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

2、编写配置文件

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

    
    <select id="getUserById" resultMap="UserMap">
        select * from user where id = #{id}
    </select>

</mapper>

<?xml version="1.0" encoding="GBK" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>

    <!--引入外部配置文件-->
    <properties resource="db.properties"/>

    <!--可以给实体类起别名-->
    <typeAliases>
        <package name="com.qin.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${pwd}"/>
            </dataSource>
        </environment>
    </environments>

    <!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="com/qin/dao/UserMapper.xml"/>
     
    </mappers>


</configuration>





driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
pwd=123456

public class UserDaoTest {

    @Test
    public void getUserLike() throws IOException {
        String resources="mybatis-config.xml";
        InputStream in = Resources.getResourceAsStream(resources);
        SqlSessionFactory sessionFactory= new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sessionFactory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User userById = mapper.getUserById(4);
        System.out.println(userById);

    }
}

(二)Mybatis-spring

1. 编写数据源配置
2. sqlSessionFactory
3. sqlSessionTemplate
4. 需要给接口加实现类
5. 将自己写的实现类，注入到Spring中，
6. 测试使用即可！

方式一sqlSessionTemplate

1.编写实体类

import lombok.Data;

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

2.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核心配置文件-->
<configuration>


    <typeAliases>
        <package name="com.qin.pojo"/>
    </typeAliases>

    <!--设置-->
    <!--<settings>-->
        <!--<setting name="" value=""/>-->
    <!--</settings> -->
</configuration>

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

    <!--DataSource:使用Spring的数据源替换Mybatis的配置  c3p0  dbcp  druid
    我们这里使用Spring提供的JDBC : org.springframework.jdbc.datasource
    -->
    <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=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定Mabatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/qin/dao/*.xml"/>
    </bean>

    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
<bean id="userMapper"  class="com.qin.dao.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"></property>
</bean>

</beans>

4.UserMapper接口

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

5、UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--configuration核心配置文件-->

<mapper namespace="com.qin.dao.UserMapper">

    <select id="selectUser" resultType="user">
        select * from mybatis.user;
    </select>

</mapper>

6、UserMapperImpl

public class UserMapperImpl implements UserMapper {

    //我们的所有操作，都使用sqlSession来执行，在原来，现在都使用SqlSessionTemplate;
    private SqlSessionTemplate sqlSession;

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

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

}

7.测试

public class MyTest {

    @Test
    public void test() throws IOException {


        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
        }

方式二 SqlSessionDaoSupport

改变了上面第六步

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

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

    <import resource="spring-dao.xml"/>

    <!---->
    <bean id="userMapper" class="com.qin.dao.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

    <bean id="userMapper2" class="com.qin.dao.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>

http://mybatis.org/spring/zh/sqlsession.html#SqlSessionTemplate

（五）声明式事务

1、回顾事务

• 把一组业务当成一个业务来做；要么都成功，要么都失败！
• 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
• 确保完整性和一致性

事务ACID原则：

**事务的原子性(Atomicity)：**是指一个事务要么全部执行，要么不执行，也就是说一个事务不可能只执行了一半就停止了。比如你从取款机取钱，这个事务可以分成两个步骤：1划卡，2出钱。不可能划了卡，而钱却没出来。这两步必须同时完成，要么就不完成。

事务**的****一致性(Consistency)：**是指事务的运行并不改变数据库中数据的一致性。例如，完整性约束了a+b=10，一个事务改变了a，那么b也应该随之改变。

**独立性(Isolation）：**事务的独立性也有称作隔离性，是指两个以上的事务不会出现交错执行的状态。因为这样可能会导致数据不一致。

持久性(Durability）：事务的持久性是指事务执行成功以后，该事务对数据库所作的更改便是持久的保存在数据库之中，不会无缘无故的回滚。

• 隔离性
  • 多个业务可能操作同一个资源，防止数据损坏
• 持久性
  • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中

2、spring中的事务管理

• 声明式事务 ： AOP
• 编程式事务： 需要再代码中，进行事务的管理

思考：

为什么需要事务？

• 如果不配置事务，可能存在数据提交不一致的情况下；
• 如果我们不在SPRING中去配置声明式事务，我们就需要在代码中手动配置事务！
• 事务在项目的开发中十分重要，设计到数据的一致性和完整性问题，不容马虎！

声明式事务 ： AOP

<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--结合AOP实现事务的织入-->
<!--配置事务通知；-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给那些方法配置事务-->
    <!--配置事务的传播特性：new  propagation= -->
    <tx:attributes>
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" propagation="REQUIRED"/>
        <tx:method name="query" read-only="true"/>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<!--配置事务切入-->
<aop:config>
    <aop:pointcut id="txPointCut" expression="execution(* com.qin.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
aSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--结合AOP实现事务的织入-->
<!--配置事务通知；-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给那些方法配置事务-->
    <!--配置事务的传播特性：new  propagation= -->
    <tx:attributes>
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" propagation="REQUIRED"/>
        <tx:method name="query" read-only="true"/>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

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