备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

80.【Spring5】（六）

2023-09-23 34
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL Serverless，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL Serverless，价值2615元额度，1个月
简介： 80.【Spring5】

(十三)、AOP

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

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

1.环境搭建

(1).导入一个jar包
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

2.方式一:使用Spring的API实现【接口实现】

(1).要求不改变原有代码增加日志

UserService接口

package Com.Jsxs.service;
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

UserService接口的实现

package Com.Jsxs.service;
public class UserServiceImp implements UserService{
    @Override
    public void add() {
        System.out.println("忝居埃就");
    }
    @Override
    public void delete() {
    }
    @Override
    public void update() {
    }
    @Override
    public void query() {
    }
}

前日志

(1).继承接口MethodBeforeAdvice
(2).重写方法
public void before(Method method, Object[] args, Object target){}
(3).参数的介绍
  method: 要执行目标对象的方法
  args: 参数
  target: 目标对象
package Com.Jsxs.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class log implements MethodBeforeAdvice {
//    method: 要执行目标对象的方法
//    args: 参数
//    target: 目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"的方法被执行了");
    }
}

后日志

(1).继承接口:AfterReturningAdvice
(2).重写方法
public void afterReturning
(3).参数的介绍
returnValue : 返回的结果
package Com.Jsxs.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
//
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法的返回结果为:"+returnValue);
    }
}

Spring配置

(1).添加约束:
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
(2).接口除外都要写bean
  <bean id="user456" class="Com.Jsxs.service.UserServiceImp"/>
    <bean id="log" class="Com.Jsxs.log.log"/>
    <bean id="alog" class="Com.Jsxs.log.AfterLog"/>
(3).注册代理
(4).切入点:expression表达式===》execution(要执行的位置 *（修饰词）*（返回值）*（类名）*（方法名）*（参数）)
<aop:pointcut id="pointcut" expression="execution(* Com.Jsxs.service.UserServiceImp.*(..))"/>
(5).执行环绕
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="alog" pointcut-ref="pointcut"/>
<?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="user456" class="Com.Jsxs.service.UserServiceImp"/>
    <bean id="log" class="Com.Jsxs.log.log"/>
    <bean id="alog" class="Com.Jsxs.log.AfterLog"/>
<!--    需要导入AOP的约束-->
<!--    注册代理-->
    <aop:config>
<!--        切入点:expression表达式===》execution(要执行的位置 *（修饰词）*（返回值）*（类名）*（方法名）*（参数）) -->
        <aop:pointcut id="pointcut" expression="execution(* Com.Jsxs.service.UserServiceImp.*(..))"/>
<!--        执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="alog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

import Com.Jsxs.service.UserService;
import Com.Jsxs.service.UserServiceImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService user =(UserService) context.getBean("user456");
        user.add();
    }
}

3.方式二:自定义实现AOP【切面定义】

配置文件

(1).自定义切面(ASPECT): 
<aop:aspect ref="切面类id">
(2).切入点(PointCut) execution(* Com.Jsxs.service.UserServiceImp.*(..))某个类的所有方法-->
<aop:pointcut id="point" expression="execution(*Com.Jsxs.service.UserServiceImp.*(..))"/>
(3).通知(Advice) method: 执行的方法名   pointcut-ref: 在哪执行 
 <aop:before method="方法" pointcut-ref="切入点id"/> 前
<aop:after method="方法" pointcut-ref="切入点id"/>后
<?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
">
<!--&lt;!&ndash;    注册bean&ndash;&gt;-->
    <bean id="user456" class="Com.Jsxs.service.UserServiceImp"/>
    <bean id="log" class="Com.Jsxs.log.log"/>
    <bean id="alog" class="Com.Jsxs.log.AfterLog"/>
    <bean id="diy" class="Com.Jsxs.diy.diy_font"/>
    <aop:config>
<!--        自定义切面-->
        <aop:aspect ref="diy">
<!--  切入点   execution(* Com.Jsxs.diy.diy_font..*(..))某个类的所有方法-->
            <aop:pointcut id="point" expression="execution(* Com.Jsxs.service.UserServiceImp..*(..))"/>
<!--   通知点      method: 执行的方法名   pointcut-ref: 在哪执行 -->
            <aop:before method="front" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

插入类

package Com.Jsxs.diy;
public class diy_font {
    public void front(){
        System.out.println("方法执行前...");
    }
    public void after(){
        System.out.println("方法执行后");
    }
}

测试

import Com.Jsxs.service.UserService;
import Com.Jsxs.service.UserServiceImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService user =(UserService) context.getBean("user456");
        user.add();
    }
}

4.方式三: 注解实现AOP

注解类

(1). 这个面变成切面类
@Aspect
(2).这个类由Spring托管，相当于创建一个bean
@Component
(3).设置通知，通知里面的内容要是切入点(在切入点前面)
@Before("execution(* Com.Jsxs.service.UserServiceImp..*(..))") 
(4).设置通知，通知里面的内容要是切入点(在切入点后面)
 @After("execution(* Com.Jsxs.service.UserServiceImp..*(..))")
(5).设置环绕
@Around("execution(* Com.Jsxs.service.UserServiceImp..*(..))")
(6).扫描包
<context:component-scan base-package="Com.Jsxs"/>
(7).开启proxy注解支持
<aop:aspectj-autoproxy/>
(8).开启注解支持
 <context:annotation-config/>
package Com.Jsxs;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/**
 * 使用注解进行实现AOP的操作
 */
@Aspect // 这个面变成切面类
@Component //这个类由Spring托管，相当于创建一个bean
public class Annocation {
    @Before("execution(* Com.Jsxs.service.UserServiceImp..*(..))") //设置通知，通知里面的内容要是切入点
    public void before(){
        System.out.println("前-------");
    }
    @After("execution(* Com.Jsxs.service.UserServiceImp..*(..))")
    public void after(){
        System.out.println("后........");
    }
    @Around("execution(* Com.Jsxs.service.UserServiceImp..*(..))")  //在环绕增强中，我们可以给定一个参数，代表我们需要切入的点
    public void around(ProceedingJoinPoint proceedingJoinPoint){
        System.out.println("环绕前");
        Signature signature = proceedingJoinPoint.getSignature();  //获取签名
        System.out.println(signature);
//        执行方法
        try {
            Object proceed = proceedingJoinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("环绕后");
    }
}

配置

<?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"
       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/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
">
    扫描包
    <context:component-scan base-package="Com.Jsxs"/>
    <bean id="user456" class="Com.Jsxs.service.UserServiceImp"/>
    <bean id="log" class="Com.Jsxs.log.log"/>
    <bean id="alog" class="Com.Jsxs.log.AfterLog"/>
    <!--    开启注解支持-->
    <aop:aspectj-autoproxy/>
    <context:annotation-config/>
</beans>

测试

import Com.Jsxs.service.UserService;
import Com.Jsxs.service.UserServiceImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService user =(UserService) context.getBean("user456");
        user.add();
    }
}

5.方式一和方式二的区别

  • 方式一: 比较全（公司常用），但是填一个方法要写一个类
  • 方式二: 简便灵活，多个方法可以添加在一个类中
  • 方式三: 维护火葬场，注解一时爽

(十四)、整合Mybatis

http://mybatis.org/spring/zh/index.html

步骤:

1.导入相关jar包

  • junit
  • mybatis
  • mysql数据库驱动
  • Spring相关的
  • aop植入
  • mybatis-spring【新的】

2.编写配置文件

3.进行测试

1.回忆Mybatis

  1. 编写实体类
  2. 编写接口
  3. 编写核心配置文件
  4. 编写Mapper文件
  5. 编写工具类
  6. 进行测试
(1).搭建环境
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
    <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=false&amp;useUnicode=true&amp;charEncoding=UTF8"/>
                <property name="username" value="root"/>
                <property name="password" value="121788"/>
            </dataSource>
        </environment>
    </environments>
    <!--    每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
      <mapper class="Com.Jsxs.Mapper.UserMapper"/>
    </mappers>
</configuration>
(2).编写工具类
package Com.Jsxs.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;
//  SqlSessionFactory---->sqlSession
public class MybatisUtil {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        String resource = "mybatis-config.xml";
        try {
//  第一步:     获取SqlSessionFactory对象
            InputStream inputStream = Resources.getResourceAsStream(resource);
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //    既然有了sqlSessionFactory,顾名思义,我们就可以从中获得SqlSession的实列了
//    sqlSession完全包含了面向数据库执行SQL命令所需要的所有方法
    public static SqlSession getSqlSession(){
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }
}
(3).编写接口实现文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="Com.Jsxs.Mapper.UserMapper">
    <select id="selectUser" resultType="Com.Jsxs.pojo.User">
        select *from mybatis.user
    </select>
</mapper>
(4).测试

2.整合Mybatis方式一(没写工具类)

(0).配置相关的依赖包

【版本要求非常高:】

切记: spring-jdbc与spring-webmvc的版本号要一致。

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
<!--        Spring链接数据库需要用到spring-jdbc-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.0.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.2</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
                <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
文章标签：
云数据库 RDS MySQL 版
日志服务
Java
Spring
mybatis
数据库连接
缓存
相关实践学习
基于CentOS快速搭建LAMP环境
本教程介绍如何搭建LAMP环境，其中LAMP分别代表Linux、Apache、MySQL和PHP。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
吉士先生
目录
相关文章
吉士先生
|
8月前
|
Java 容器 Spring
80.【Spring5】（二）
80.【Spring5】
吉士先生
23 0
游客i66wb7w7cg4tk
|
27天前
|
Java 程序员 Maven
Spring(一）
Spring(一）
游客i66wb7w7cg4tk
11 1
朱琳均
|
5月前
|
Java 应用服务中间件 程序员
spring
spring
朱琳均
37 0
程序媛地瓜
|
9月前
|
设计模式 前端开发 Java
Spring 详解
Spring 详解
程序媛地瓜
25318 5
osc_06552749
|
10月前
|
Java Spring
Spring 是什么？
Spring 是什么？
osc_06552749
42 0
游客l5slbacchravc
|
XML Java 程序员
Spring详细总结3
Spring详细总结3
游客l5slbacchravc
196 0
Spring详细总结3
龙哥手记
|
Java Spring
Spring BeanDefinitionReaderUtils详解
《读尽源码》
龙哥手记
118 0
龙哥手记
|
Java Spring
Spring OrderUtils详解
《读尽源码》
龙哥手记
187 0
游客edclamv6jo6kk
|
XML SQL Java
Spring
这篇文章为Spring学习笔记
游客edclamv6jo6kk
163 0
陈卸甲
|
XML Java 数据格式
Spring 使用详解
Spring 使用详解
陈卸甲
116 0
Spring 使用详解

热门文章

最新文章

  • 1
    解决关于Windows Defender Antivirus Service自启造成运行python程序时，Windows的cpu和内存占用过高问题
  • 2
    订票系统不再瘫痪 阿里云确认与12306合作
  • 3
    iOS - 手动下架的应用后快速恢复上架
  • 4
    du 和 df以及lsof
  • 5
    库克：苹果不是只做富人生意，还一直坚持让世界变得更好
  • 6
    WiGig无线标准正式开始提供验证 最高可达8Gbps
  • 7
    IBM推出新的16位量子处理器
  • 8
    Android:随笔——对页面的View进行截图
  • 9
    shell MAC 地址 校验
  • 10
    【系统优化】数据库系统load飙高问题解决思路
  • 1
    DataWorks产品使用合集之DataWorks中，如果一个虚拟节点被设置为冻结状态，那么它的所有子节点也将被冻结如何解决
    22
  • 2
    DataWorks产品使用合集之DataWorks发布任务的方法如何解决
    25
  • 3
    DataWorks产品使用合集之DataWorks中，配置DataHub数据源如何解决
    22
  • 4
    Nacos 1.4.1核心功能组件及使用入门
    22
  • 5
    DataWorks产品使用合集之在 DataWorks 中，有一个 MySQL 数据表，数据量非常大且数据会不断更新将这些数据同步到 DataWorks如何解决
    14
  • 6
    基于直方图的图像阈值计算和分割算法FPGA实现,包含tb测试文件和MATLAB辅助验证
    13
  • 7
    DataWorks产品使用合集之在DataWorks中，要实现MySQL数据源的增量同步如何解决
    16

    • 相关课程

    更多
  • 5天实战Spring Boot 2.5
  • 5天突破Spring Cloud
  • Spring Boot 2.5.x开发实战
  • 精通Spring Cloud Alibaba
  • Spring Cloud Alibaba Nacos 详解（上）
  • Spring Cloud Alibaba Nacos 详解（下）

    • 相关电子书

    更多
  • Spring Boot 2.5开发实战
  • Java Spring Boot开发实战系列课程【第15讲】：Spring Boot 2.0 API与Spring REST Docs实战
  • Spring Cloud Alibaba 从入门到实战

    • 相关实验场景

    更多
  • Spring-cloud-bus-rocketmq入门与实践
  • Rocketmq-spring入门与实践
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考