spring框架 AOP

10、 代理模式

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

代理模式的分类：

• 静态代理
• 动态代理

10.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();
           fee();
       }
       //看房
       public void seeHouse(){
           System.out.println("中介带你看房");
       }
       //签合同
       public void hetong(){
           System.out.println("签合同");
       }
       //收费
       public void fee(){
           System.out.println("收取中介费用");
       }
   }
   

4. 客户端访问

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

代理模式的好处：

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

缺点：

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

10.2 加深理解

代码：对应10-demo02

聊聊AOP

10.3 动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的。
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  • 基于接口——JDK动态代理
  • 基于类：cglib
  • java字节码实现：javasisit

需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序

动态代理的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共也就交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理！
• 一个动态代理类代理类代理的是一个接口，一般就是对应的一类业务
• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

//自动生成代理类
public class InvocationHandlerProxy 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 {

       Object result = method.invoke(target, args);
       return result;
   }
}

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，暂时没有
        InvocationHandlerProxy proxy = new InvocationHandlerProxy();
        //设置要代理的对象
        proxy.setTarget(userService);
        //动态生成代理类
        UserService proxy1 = (UserService) proxy.getProxy();

        proxy1.add();

    }
}

11、 AOP

11.1 什么是AOP

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

image.png

11.2 AOP在Spring中的作用

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

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

image.png

11.3 使用Spring实现AOP

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

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

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

 <aop:config proxy-target-class="true">
<!--切入点-->
     <aop:pointcut id="pointcut" expression="execution(* com.service.UserServiceImpl.*(..))"/>
<!--执行环绕-->
     <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
     <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
 </aop:config>

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

 <bean id="diy" class="com.diy.DiyPointcut"/>
    <aop:config proxy-target-class="true">
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

方式三：使用注解实现

  <!--注解支持-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <!--方式三-->
    <bean id="diyAnnotation" class="com.diy.DiyAnnotation"/>

常用注解：
@Aspect：写下类上，标注类是一个切面
@Before("execution(* com.service.UserServiceImpl.(..))")
@After("execution( com.service.UserServiceImpl.(..))")
@Around("execution( com.service.UserServiceImpl.*(..))")
括号里面是切入点

12、 整合Mybatis

步骤：

1. 导入相关jar包
   • junit
   • Mybatis
   • mysql数据库
   • spring相关的
   • aop织入
   • mybatis-spring【new知识点】
2. 编写配置文件
3. 测试

12.1 回忆mybatis

1. 编写实体类
2. 编写核心配置文件
3. 编写接口
4. 编写Mapper.xml
5. 测试

12.2 Mybatis-Spring

1. 编写数据源配置

<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>

2. sqlSessionFactory

<!--定义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:com/dao/UserMapper.xml"/>
    </bean>

3. sqlSessionTemplate

 <!--定义sqlSessionTemplet-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

4. 需要给接口加实现类

public class UserMapperImpl implements UserMapper{
    private SqlSessionTemplate sqlSession;

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

    @Override
    public List<User> queryUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.queryUser();

    }
}

5. 将自己写的实现类，注入到Spring中

<bean id="userMapperImpl" class="com.dao.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

6. 测试

public class MyTest {

    @Test
    public void test1() throws IOException {

        ApplicationContext context = new ClassPathXmlApplicationContext("spring.config.xml");

        UserMapper userMapperImpl = context.getBean("userMapperImpl", UserMapper.class);

        List<User> users = userMapperImpl.queryUser();

        for (User user : users) {
            System.out.println(user);
        }
    }
}

13、 声明式事务

13.1 回顾事务

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

事务ADID原则：

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

13.2 Spring中的事务管理

• 声明式事务：AOP

配置声明事务

 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource" />
    </bean>

结合AOP实现事务的织入

<tx:advice id="transactionInterceptor" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

配置切入

<aop:config proxy-target-class="true">
       <aop:pointcut id="txPointcut" expression="execution(* com.mapper.*.*(..))"/>
       <aop:advisor advice-ref="transactionInterceptor" pointcut-ref="txPointcut"/>
   </aop:config>

• 编程式事务：需要在代码中，进行事务的管理

思考：

为什么需要事务？

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