Spring(三)

Spring(三)

Spring(三)

代理模式

静态代理

角色分析
- 抽象角色：一般会使用接口或者抽象类
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作
- 客户：访问代理对象的人
优点：
- 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
- 公共业务交给代理角色，实现业务的分工
- 公共业务发生扩展的时候，方便集中管理
缺点：
- 一个真实角色就会产生一个代理角色，代码量翻倍，开发效率会变低

动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是直接写好的
动态代理分类：
- 基于接口的动态代理：JDK动态代理
- 基于类的动态代理：cglib
- java字节码实现：javasist
两个类：Proxy、InvocationHandler
抽象角色：

public interface Rent {
    public void rent();
}

真实角色：

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

生成代理类：

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);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射实现
        Object result = method.invoke(rent, args);
        return result;
    }
}

客户

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host);
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

AOP

定义

AOP面向切面编程：通过预编译方式和运行动态代理实现程序功能的统一维护的一种技术

AOP在Spring中的作用

提供声明式事务，允许用户自定义切面
名词解释：
- 横切关注点：跨越应用程序多个模块的方法或功能，即与我们业务逻辑无关，但需要关注的部分，如日志、安全、缓存、事务等
- 切面(Aspect)：横切关注点被模块化的特殊对象，是一个类
- 通知(Advice)：切面必须要完成的工作，是一个方法
- 目标(Target)：被通知的对象
- 代理(Proxy)：向目标对象应用通知后创建的对象
- 切入点(PointCut)：切面通知执行的“地点”的定义
- 连接点(JointPoint)：与切入点匹配的执行点
SpringAOP中，通过Advice定义横切逻辑，支持5中类型的Advice：

通知类型	连接点	实现接口
前置通知	方法前	org.springframework.aop.MethodBeforeAdvice
后置通知	方法后	org.springframework.aop.AfterReturningAdvice
环绕通知	方法前后	org.aopalliance.intercept.MethodIntercreptor
异常抛出通知	方法抛出异常	org.springframework.aop.ThrowsAdvice
引介通知	类中增加新的方法属性	org.springframework.aop.IntroductionInterceptor

使用Spring实现AOP

导入依赖

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

方式一：使用Spring的API接口

服务接口：

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

服务实现类：

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 select() {
        System.out.println("查询了一个用户");
    }
}

前置通知

public class Log implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        //方法，参数，对象
        System.out.println(o.getClass().getName() + "的" + method.getName());
    }
}

后置通知

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        //返回值，方法，参数，对象
        System.out.println("执行了" + method.getName() + "方法，返回结果为：" + o);
    }
}

定义bean以及切入点和通知

<?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="userService" class="com.yhr.service.UserServiceImpl"/>
    <bean id="log" class="com.yhr.log.Log"/>
    <bean id="afterLog" class="com.yhr.log.AfterLog"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置AOP：需要导入aop的约束-->
    <aop:config>
        <!--切入点--> 
        <!--execution(返回值 包名.类名.方法名(参数))-->
        <aop:pointcut id="pointcut" expression="execution(* com.yhr.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

测试：

@Test
public void test() {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //动态代理接口
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

方式二：自定义类

自定义切面

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

注册bean以及切面

<?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="userService" class="com.yhr.service.UserServiceImpl"/>

    <!--方式二：自定义类-->
    <bean id="diy" class="com.yhr.diy.DiyPointCut"/>
    <aop:config>
        <!--自定义切面-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.yhr.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

</beans>

方式三：使用注解实现

切面类

//使用注解方式实现AOP
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.yhr.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("方法执行前");
    }

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

    //在环绕增强中，可以给定一个参数，代表要获取处理切入的点
    @Around("execution(* com.yhr.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}

注册bean以及开启注解支持

<?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="userService" class="com.yhr.service.UserServiceImpl"/>

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

</beans>

整合MyBatis

导入依赖包

spring-jdbc

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.12.RELEASE</version>
</dependency>

mybatis-spring

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
</dependency>

方式一：SqlSessionTemplate

在springDao.xml中配置MyBatis

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

    <!--DataSource 使用Spring的数据源替换MyBatis的配置 c3p0 dbcp druid
    这里使用Spring提供的jdbc-->
    <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=false&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"/>
        <!--绑定MyBatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/yhr/mapper/*.xml"/>
    </bean>

    <!--使用SqlSessionTemplate无缝代替SqlSession-->
    <!--SqlSessionTemplate是线程安全的，可以被多个DAO或映射器共同使用-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--没有setter方法，只能使用构造器注入-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

</beans>

编写实现类

@Data
public class UserMapperImpl implements UserMapper{
    private SqlSession sqlSession;

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

在applicationContext.xml中导入MyBatis配置，绑定实现类，注入SqlSession

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

    <import resource="springDao.xml"/>

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

</beans>

测试

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserMapperImpl userMapperImpl = context.getBean("userMapperImpl", UserMapperImpl.class);
    List<User> users = userMapperImpl.selectUser();
    for (User user : users) {
        System.out.println(user);
    }
}

方式二：SqlSessionDaoSupport

继承SqlSessionDaoSupport，直接获取SqlSession

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List<User> selectUser() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

注入SqlSessionFactory

<bean id="userMapperImpl2" class="com.yhr.mapper.UserMapperImpl2">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

声明式事务

声明式事务：AOP
编程式事务：需要在代码中进行事务的管理
- try..catch...rollback...

配置方式

<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--结合AOP实现事务的织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给哪些方法配置事务-->
    <!--配置事务的传播特性 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.yhr.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

posted @ 2021-02-04 17:21 一天到晚睡觉的鱼阅读(65) 评论(0) 收藏举报

刷新页面返回顶部

一天到晚睡觉的鱼

Spring(三)

Spring(三)

代理模式

静态代理

动态代理

AOP

定义

AOP在Spring中的作用

使用Spring实现AOP

方式一：使用Spring的API接口

方式二：自定义类

方式三：使用注解实现

整合MyBatis

方式一：SqlSessionTemplate

方式二：SqlSessionDaoSupport

声明式事务

配置方式

公告