java企业级信息系统开发学习笔记02初探spring——利用组件注解符精简spring配置文件

Posted 2023-04-01 人生苦短@我用python

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java企业级信息系统开发学习笔记02初探spring——利用组件注解符精简spring配置文件相关的知识，希望对你有一定的参考价值。

文章目录

一、学习目标
二、打开01的项目
三、利用组件注解符精简spring配置文件
四、程序优化-面向接口

一、学习目标

1.掌握采用组件注解符精简Spring配置文件
2.理解面向接口优化程序结构的思想

二、打开01的项目

三、利用组件注解符精简spring配置文件

（一）创建新包，复制四个类

（二）修改杀龙任务类

杀龙任务类 - SlayDragonQuest
给Java类添加组件注解符@Component，意味着要交给Spring容器管理，如果没有设置参数，那么组件采用默认名称，就是类名首字母小写 - slayDragonQuest

package net.huawei.spring.day02;

import org.springframework.stereotype.Component;

/**
 * 功能：杀龙任务类
 * 作者：华卫
 * 日期：2023年02月13日
 */
@Component
public class SlayDragonQuest 
    public void embark() 
        System.out.println("执行杀龙任务……");

（三）修改救美任务类

救美任务类 - RescueDamselQuest

package net.huawei.spring.day02;

import org.springframework.stereotype.Component;

/**
 * 功能：救美任务类
 * 作者：华卫
 * 日期：2023年02月20日
 */
@Component
public class RescueDamselQuest 
    public void embark() 
        System.out.println("执行救美任务……");

（四）修改勇敢骑士类

勇敢骑士类 - BraveKnight

package net.huawei.spring.day02;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 功能：勇敢骑士类
 * 作者：华卫
 * 日期：2023年02月20日
 */
@Component("RobinHood")
public class BraveKnight 
    @Value("罗宾汉") // 值注解符
    private String name;
    @Autowired // 自动装配注解符
    private SlayDragonQuest slayDragonQuest;

    /**
     * 勇敢骑士执行任务
     */
    public void embarkOnQuest() 
        System.out.print("勇敢骑士[" + name + "]"); // 骑士留名
        slayDragonQuest.embark(); // 执行杀龙任务

（五）修改救美骑士类

救美骑士类 - DamselRescuingKnight，添加组件注解符，自动配置两个属性

package net.huawei.spring.day02;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 功能：救美骑士类
 * 作者：华卫
 * 日期：2023年02月20日
 */
@Component
public class RescueDamselKnight 
    @Value("格拉海德") // 值注解符
    private String name;
    @Autowired // 自动装配注解符
    private RescueDamselQuest rescueDamselQuest;

    public void embarkOnQuest() 
        System.out.print("救美骑士[" + name + "]");
        rescueDamselQuest.embark();

（六）创建spring配置文件

在resources目录创建xml_annotation子目录，然后在里面创建Spring配置文件 - spring-config.xml
组件扫描：扫描指定包下添加了注解符的类（@Component、@Service、@Repository、@Mapper、@Controller），将其生成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: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
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--组件扫描，扫描指定包下添加了注解符的类或接口，将其生成Bean对象-->
    <context:component-scan base-package="net.huawei.spring.day02" />
</beans>

（七）创建测试类

在test/java里创建net.huawei.spring.day02包，在包里创建TestKnight类

package net.huawei.spring.day02;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 功能：测试骑士类
 * 作者：华卫
 * 日期：2023年02月20日
 */
public class TestKnight 
    private ClassPathXmlApplicationContext context; // 基于类路径XML配置文件的应用容器
    
    @Before
    public void init() 
        // 基于Spring配置文件创建应用容器
        context = new ClassPathXmlApplicationContext("xml_annotation/spring-config.xml");
    
    
    @Test
    public void testKnight() 
        // 根据名称从应用容器里获取勇敢骑士对象
        BraveKnight knight1 = (BraveKnight) context.getBean("RobinHood");
        // 勇敢骑士执行任务
        knight1.embarkOnQuest();
        // 根据名称从应用容器里获取救美骑士对象
        RescueDamselKnight knight2 = (RescueDamselKnight) context.getBean("rescueDamselKnight");
        // 救美骑士执行任务
        knight2.embarkOnQuest();
    
    
    @After
    public void destroy() 
        // 关闭应用容器
        context.close();

四、程序优化-面向接口

Spring框架可以方便地管理Bean及其相互依赖。为了模块之间实现松耦合，一般采用面向接口的方式。多种骑士，多种任务，可以任意搭配。为了实现这个效果，我们应该抽象出两个接口：骑士接口（Knight）和任务接口（Quest）。骑士接口有两个实现类：BraveKnight和DamselRescuingKnight；任务接口有两个实现类：SlayDragonQuest和RescueDamselQuest。

（一）创建任务接口

package net.huawei.spring.day02;

/**
 * 功能：任务接口
 * 作者：华卫
 * 日期：2023年02月20日
 */
public interface Quest 
    void embark();

（二）创建骑士接口

package net.huawei.spring.day02;

/**
 * 功能：骑士接口
 * 作者：华卫
 * 日期：2023年02月20日
 */
public interface Knight 
    void embarkOnQuest();

（三）修改杀龙任务类

（四）修改救美任务类

（五）修改勇敢骑士类

（六）修改救美骑士类

（七）修改测试类

（八）运行测试类

企业级信息系统开发学习笔记1.5 初探Spring AOP

零、本讲学习目标

理解AOP与OOP的关系
掌握采用配置方式使用AOP
掌握采用注解方式使用AOP

一、Spring AOP

（一）AOP基本含义

AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。
OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

（二）AOP基本作用

软件开发原则：高内聚，低耦合
Spring的AOP作用在于解耦。AOP让一组类共享相同的行为（比如事务管理、日志管理、安全管理）。
OOP（Object-Oriented Programming）只能通过继承类或实现接口来增加代码的耦合度，而且类继承是单根继承（不允许一子多父），阻碍了将更多的行为添加到一组类上，此时AOP可以弥补OOP的不足。

（三）AOP与OOP对比

AOP（Aspect-Oriented Programming）—— 横向的关系
OOP（Object-Oriented Programming）—— 纵向的关系

（四）AOP使用方式

Spring采用配置方式使用AOP
Spring采用注解方式使用AOP

（五）AOP基本概念

Aspect（切面）：通常是一个类，里面可以定义切入点和通知
JointPoint（连接点）：程序执行过程中明确的点，一般是方法的调用
Advice（通知）：AOP在特定的切入点上执行的增强处理，有before、after、after-returning、after-throwing、around
Pointcut（切入点）：就是带有通知的连接点，在程序中主要体现为书写切入点表达式
AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

二、提出游吟诗人唱赞歌任务

骑士执行任务前和执行任务后，游吟诗人唱赞歌

（一）采用传统方式实现

修改day04子包的勇敢骑士类
修改day04子包里的救美骑士类
执行测试类 - TestKnight

（二）采用传统方式实现的缺点

每个骑士类的embarkOnQuest()方法都要修改，耦合度太高，当骑士类数量很大时，这个任务完成起来就十分枯燥繁琐。

下面我们采用AOP方式来实现同样的功能，大家通过对比可以更好地体会采用AOP方式的优越性。

三、采用配置方式使用AOP

（一）创建本讲所需子包

在net.huawei.spring包里创建day05.aop_xml子包

（二）创建杀龙任务类

在aop_xml子包里创建杀龙任务类 - SlayDragonQuest

package net.huawei.spring.day05.aop_xml;

import org.springframework.stereotype.Component;

/**
 * 功能：杀龙任务类
 * 作者：华卫
 * 日期：2023年02月22日
 */
@Component
public class SlayDragonQuest 
    public void embark() 
        System.out.println("执行杀龙任务……");

（三）创建勇敢骑士类

在aop_xml子包里创建勇敢骑士类 - BraveKnight

package net.huawei.spring.day05.aop_xml;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 功能：勇敢骑士类
 * 作者：华卫
 * 日期：2023年02月22日
 */
@Component("RobinHood")
public class BraveKnight 
    @Value("罗宾汉")
    private String name;
    @Autowired
    private SlayDragonQuest slayDragonQuest;
    
    public void embarkOnQuest() 
        System.out.print("勇敢骑士[" + name + "]");
        slayDragonQuest.embark();

（四）创建游吟诗人类

在aop_xml子包里创建游吟诗人类 - Minstrel

package net.huawei.spring.day05.aop_xml;

import org.springframework.stereotype.Component;

/**
 * 功能：游吟诗人类
 * 作者：华卫
 * 日期：2023年02月22日
 */
@Component
public class Minstrel 
    /**
     * 骑士出发前唱赞歌
     */
    public void singBeforeQuest() 
        System.out.println("啦啦啦，骑士出发了~");
    

    /**
     * 骑士凯旋时唱赞歌
     */
    public void singAfterQuest() 
        System.out.println("真棒啊！骑士完成了任务~");

（五）创建Spring配置文件

在resources里创建aop_xml目录，在里面创建spring-config.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:context="http://www.springframework.org/schema/context"
       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 
       https://www.springframework.org/schema/context/spring-context.xsd 
       http://www.springframework.org/schema/aop 
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!--组件扫描-->
    <context:component-scan base-package="net.huawei.spring.day05.aop_xml"/>

    <!--配置AOP-->
    <aop:config>
        <!--定义切面-->
        <aop:aspect ref="minstrel">
            <!--定义切点-->
            <aop:pointcut id="embark" expression="execution(* net.huawei.spring.day05..*.embarkOnQuest(..))"/>
            <!--声明前置通知-->
            <aop:before method="singBeforeQuest" pointcut-ref="embark"/>
            <!--声明后置通知-->
            <aop:after method="singAfterQuest" pointcut-ref="embark"/>
        </aop:aspect>
    </aop:config>
</beans>

1、切点

在使用Spring框架配置AOP时，不管是通过XML配置文件还是注解方式，都需要定义pointcut（切点）。

2、切点表达式

拦截指定包及其子包下所有类的指定方法："execution(* net.huawei.spring.day05..*.embarkOnQuest(..))"
拦截指定包及其子包下所有类的所有方法："execution(* net.huawei.spring.day05..*.*(..))"

3、切点函数

execution()是最常用的切点函数，整个表达式可以分为五个部分。

execution()：表达式主体。
第一个*号：表示返回类型，*号表示所有的类型。
包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，`net.huaweispring.day05包、子孙包下所有类的方法。
第二个*号：表示类名，*号表示所有的类。
*(..)：最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。

（六）添加AOP相关依赖

在pom.xml文件里添加AOP相关依赖

<!--Spring AOP-->                                         
<dependency>                                              
    <groupId>org.springframework</groupId>                
    <artifactId>spring-aop</artifactId>                   
    <version>5.3.25</version>                  
</dependency>                                             
<!--AspectJ支持-->                                          
<dependency>                                              
    <groupId>aspectj</groupId>                            
    <artifactId>aspectjrt</artifactId>                    
    <version>1.5.4</version>                              
</dependency>                                             
<dependency>                                              
    <groupId>org.aspectj</groupId>                        
    <artifactId>aspectjweaver</artifactId>                
    <version>1.9.19</version>                              
    <scope>runtime</scope>                                
</dependency>

注意：添加新的依赖之后，记得更新

（七）创建测试类 - TestKnight

在test/java里创建net.huawei.spring.day05.aop_xml包，在包里创建TestKnight类

package net.huawei.spring.day05.aop_xml;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 功能：测试骑士类
 * 作者：华卫
 * 日期：2023年02月22日
 */
public class TestKnight 
    private ClassPathXmlApplicationContext context; // 基于类路径XML配置文件的应用容器

    @Before 
    public void init() 
        // 基于Spring配置文件创建应用容器
        context = new ClassPathXmlApplicationContext("aop_xml/spring-config.xml");        
    
    
    @Test
    public void testBraveKnight() 
        // 根据名称从应用容器里获取勇敢骑士对象
        BraveKnight braveKnight = (BraveKnight) context.getBean("RobinHood");
        // 勇敢骑士执行任务
        braveKnight.embarkOnQuest();
    

    @After 
    public void destroy() 
        // 关闭应用容器
        context.close();

（八）运行测试方法，查看结果

运行testBraveKinght()方法

（九）课堂练习

1、创建救美任务类与救美骑士类

创建RescueDamselQuest类和RescueDamselKnight类

2、在测试类里增加测试方法

测试方法 - testRescueDamselKnight()

3、运行测试类，查看结果

运行testKnight类

四、采用注解方式使用AOP

（一）创建本讲所需子包

在net.hw.spring包里创建lesson05.aop_annotation子包

（二）创建杀龙任务类

在aop_annotation子包里创建杀龙任务类 - SlayDragonQuest

package net.hw.spring.lesson05.aop_annotation;

import org.springframework.stereotype.Component;

/**
 * 功能：杀龙任务类
 * 作者：华卫
 * 日期：2021年03月29日
 */
@Component
public class SlayDragonQuest 
    public void embark() 
        System.out.println("执行杀龙任务。");

（三）创建勇敢骑士类

在aop_annotation子包里创建勇敢骑士类 - BraveKnight

package net.hw.spring.lesson05.aop_annotation;

/**
 * 功能：勇敢骑士类
 * 作者：华卫
 * 日期：2021年03月29日
 */

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component("Mike")
public class BraveKnight 
    @Autowired
    private SlayDragonQuest slayDragonQuest;

    public void embarkOnQuest() 
        slayDragonQuest.embark();

（四）创建游吟诗人切面

在aop_annotation子包里创建游吟诗人切面 - MinstrelAspect

package net.hw.spring.lesson05.aop_annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 功能：游吟诗人切面
 * 作者：华卫
 * 日期：2021年03月29日
 */
@Aspect // 声明为切面
@Component // 交给Spring容器管理
public class MinstrelAspect 
    // 注解声明切点
    @Pointcut("execution(* net.hw.spring.lesson05..*.embarkOnQuest(..))")
    public void embark() 
    

    // 注解声明前置通知
    @Before("embark()")
    public void singBeforeQuest(JoinPoint joinPoint) 
        System.out.println("啦啦啦，骑士出发了！");
    

    // 注解声明后置通知
    @After("embark()")
    public void singAfterQuest(JoinPoint joinPoint) 
        System.out.println("真棒啊！骑士完成了任务！");

（五）创建Spring配置类

在aop_annotation子包里创建Spring配置类 - AopConfig

package net.hw.spring.lesson05.aop_annotation;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * 功能：AOP配置类
 * 作者：华卫
 * 日期：2021年03月29日
 */
@Configuration // 标明Spring配置类
@ComponentScan("net.hw.spring.lesson05.aop_annotation") // 组件扫描
@EnableAspectJAutoProxy // 开启Spring对AspectJ的支持
public class AopConfig

（六）创建骑士测试类

在test/java/aop_annotation子包里创建测试类 - TestKnight

package net.hw.spring.lesson05.aop_annotation;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 功能：测试骑士类
 * 作者：华卫
 * 日期：2021年03月29日
 */
public class TestKnight 

    private AnnotationConfigApplicationContext context; // 基于注解配置类的应用容器

    @Before
    public void init() 
        // 基于注解配置类创建应用容器
        context = new AnnotationConfigApplicationContext(AopConfig.class);
    

    @Test
    public void testBraveKnight() 
        // 根据名称从应用容器里获取勇敢骑士对象
        BraveKnight knight = (BraveKnight) context.getBean("Mike");
        // 勇敢骑士执行任务
        knight.embarkOnQuest();
    

    @After
    public void destroy() 
        // 关闭应用容器
        context.close();

（七）运行测试方法testBraveKnight()，查看效果

（八）课堂练习

1、增加救美任务类与救美骑士类

2、在测试类里增救美骑士测试方法 - testDamselRescuingKnight()

3、运行testDamselRescuingKnight()方法，查看结果

五、实现注解式拦截

（一）拦截的含义

在某个方法被访问之前进行拦截，然后在方法执行之前或之后加入某些操作，其实就是AOP的一种实现策略。Spring提供拦截器（Interceptor），它通过动态拦截Action调用的对象，允许开发者定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。本案例，我们不用拦截器，学习注解式拦截。

（二）创建注解接口

在aop_annotation子包里创建注解接口 - Action

package net.hw.spring.lesson05.aop_annotation;

import java.lang.annotation.*;

/**
 * 功能：动作注解接口
 * 作者：华卫
 * 日期：2021年03月29日
 */
@Target(ElementType.METHOD) // 拦截目标 - 方法
@Retention(RetentionPolicy.RUNTIME) // 保留策略 - 运行时
@Documented // 注解文档化
public @interface Action 
    String name();