学会SpringMVC之自定义注解各种场景应用，提高开发效率及代码质量-阿里云开发者社区

一、简介

( 1 ) 是什么

在Spring MVC中，自定义注解是一种通过Java语言提供的元注解机制，用于在控制器方法、参数、类等地方添加注解，从而实现特定的功能或行为。

在Spring MVC中，自定义注解是一种用于标记和定义特定功能的注解。通过自定义注解，可以在控制器方法、参数、类等地方添加注解，从而实现特定的功能或行为。

Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解相关类都包含在java.lang.annotation包中

通过自定义注解，可以提高代码的可读性和可维护性，同时也可以减少重复的代码编写。在Spring MVC中，可以使用Java的元注解来定义自定义注解，例如@Target、@Retention、@Documented等。

通过自定义注解，可以提高代码的可读性和可维护性，同时也可以减少重复的代码编写。在Spring MVC中，自定义注解可以应用于控制器方法的映射、参数校验、数据绑定、AOP切面等方面，从而实现特定的功能。

( 2 ) 分类

Java注解可以分为三类：

1. 元注解（Meta-Annotation）：元注解是用来注解其他注解的注解，用于对注解进行说明和定义。常用的元注解有四种：

- @Retention：用于指定注解的保留策略，即注解在什么地方有效。
有三个取值：RetentionPolicy.SOURCE（注解仅在源代码中有效）、RetentionPolicy.CLASS（注解在源代码和class文件中有效，默认值）、RetentionPolicy.RUNTIME（注解在运行时有效）。
- @Target：用于指定注解的作用目标，即注解可以应用在哪些元素上。
常用的取值有：ElementType.TYPE（类、接口、枚举）、ElementType.FIELD（字段）、ElementType.METHOD（方法）、ElementType.PARAMETER（方法参数）、ElementType.CONSTRUCTOR（构造函数）、ElementType.LOCAL_VARIABLE（局部变量）、ElementType.ANNOTATION_TYPE（注解）、ElementType.PACKAGE（包）等。
- @Documented：用于指定注解是否包含在JavaDoc中。
- @Inherited：用于指定注解是否可以被继承。

2. 基本注解（Built-in Annotation）：基本注解是Java内置的一些注解，用于标记和修饰代码。常用的基本注解有三个：

- @Override：用于标记方法覆盖父类的方法。
- @Deprecated：用于标记已过时的方法、类或字段。
- @SuppressWarnings：用于抑制编译器警告。

3. 自定义注解（Custom Annotation）：自定义注解是开发者根据业务需求自行定义的注解，用于标记和修饰代码。自定义注解可以通过元注解的方式进行配置，以达到特定的目的。自定义注解的作用可以是：

- 标记和识别特定的代码逻辑或功能。
- 提供额外的元数据，用于生成文档、配置文件等。
- 在运行时通过反射获取注解信息，实现一些特定的逻辑。
- 与其他框架或工具进行集成，实现特定的功能。

总结：元注解用于对其他注解进行说明和定义，基本注解是Java内置的用于标记和修饰代码的注解，而自定义注解是根据业务需求自行定义的注解，用于标记和修饰代码，并提供额外的元数据和功能。

( 3 ) 作用

在Spring MVC中，自定义注解可以用于实现以下功能：

1. 请求映射：可以使用自定义注解来标记Controller中的方法，用于指定请求的URL路径和请求方法。例如，可以定义一个自定义注解`@GetMapping`，用于标记处理GET请求的方法，简化了在`@RequestMapping`中指定请求方法的操作。

2. 参数绑定：可以使用自定义注解来标记Controller中方法的参数，用于指定参数的来源和绑定规则。例如，可以定义一个自定义注解`@PathVariable`，用于标记方法参数，表示该参数从URL路径中获取。

3. 参数校验：可以使用自定义注解来标记方法的参数，用于指定参数的校验规则。例如，可以定义一个自定义注解`@Valid`，用于标记方法参数，表示该参数需要进行校验。

4. AOP切面：可以使用自定义注解来标记需要进行AOP切面处理的方法或类。例如，可以定义一个自定义注解`@Log`，用于标记需要记录日志的方法，然后通过AOP切面对标记了`@Log`注解的方法进行日志记录。

5. 权限控制：可以使用自定义注解来标记需要进行权限控制的方法或类。例如，可以定义一个自定义注解`@RequiresPermission`，用于标记需要进行权限验证的方法，然后通过AOP切面对标记了`@RequiresPermission`注解的方法进行权限验证。

通过自定义注解，可以使代码更加简洁、易读，并且可以实现一些特定的功能，提高开发效率和代码的可维护性。在Spring MVC中，自定义注解的应用非常广泛，可以根据具体的业务需求进行自定义注解的定义和使用。

二、自定义注解

( 1 ) 如何自定义注解

要自定义注解，需要使用Java提供的元注解来对注解进行配置，然后使用@interface关键字定义注解的名称和属性。以下是自定义注解的步骤：

1 . 使用元注解配置注解的行为和作用范围。常用的元注解有：

@Retention：用于指定注解的生命周期。常用的取值有RetentionPolicy.SOURCE（注解在编译期丢弃）、RetentionPolicy.CLASS（注解在编译期保留，但在运行时丢弃，默认值）、RetentionPolicy.RUNTIME（注解在运行时保留）。

@Target：用于指定注解的作用目标。常用的取值有ElementType.TYPE（类、接口、枚举）、ElementType.FIELD（字段）、ElementType.METHOD（方法）、ElementType.PARAMETER（方法参数）、ElementType.CONSTRUCTOR（构造函数）、ElementType.LOCAL_VARIABLE（局部变量）、ElementType.ANNOTATION_TYPE（注解）、ElementType.PACKAGE（包）等。

@Documented：用于指定注解是否包含在JavaDoc中。

@Inherited：用于指定注解是否可以被继承。

@Deprecated：用于标记已过时的注解。当一个注解被标记为@Deprecated时，表示该注解已不推荐使用，可以使用其他替代的注解。

@Native：用于指定注解是否为本地注解。本地注解是指由JDK或第三方库提供的注解，而不是自定义的注解。

@SuppressWarnings：用于抑制编译器警告。可以使用@SuppressWarnings注解来忽略特定的警告信息，例如未使用的变量、未检查的类型转换等。

2 . 使用@interface关键字定义注解的名称和属性。注解的名称可以是任意合法的Java标识符，通常以大写字母开头。注解的属性使用方法类似于接口的方法，可以指定默认值。

3 . 在需要使用注解的地方使用注解。可以在类、方法、字段等地方使用自定义注解，并根据注解的属性进行配置。

4 . 在运行时通过反射获取注解信息。可以使用Java的反射机制，在运行时获取类、方法、字段等上的注解信息，并根据注解的属性进行特定的逻辑处理。

以下是一个示例，演示了如何自定义一个简单的注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value() default "";
    int count() default 0;
}

在上面的示例中，定义了一个名为MyAnnotation的注解，使用了@Retention(RetentionPolicy.RUNTIME)元注解指定了注解在运行时保留，使用了@Target(ElementType.METHOD)元注解指定了注解可以应用在方法上。注解中定义了两个属性，一个是value，一个是count，并指定了默认值。

然后可以在需要使用注解的地方使用@MyAnnotation来标记方法，

并根据需要配置注解的属性值：

@MyAnnotation(value = "Hello", count = 10)
public void myMethod() {
    // do something
}

在运行时，可以使用反射来获取注解的信息：

Method method = MyClass.class.getMethod("myMethod");
MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
String value = annotation.value(); // 获取注解的属性值
int count = annotation.count();

通过以上步骤，就可以自定义注解并在代码中使用了。根据具体的业务需求，可以定义不同的注解，并使用注解来实现特定的功能。

( 2 ) 场景演示

创建完项目之后，找到 pom.xml 配置文件，进行项目引用导入。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>CloudJunzySSM</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>CloudJunzySSM Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.plugin.version>3.7.0</maven.compiler.plugin.version>
    <!--添加jar包依赖-->
    <!--1.spring 5.0.2.RELEASE相关-->
    <spring.version>5.0.2.RELEASE</spring.version>
    <!--2.mybatis相关-->
    <mybatis.version>3.4.5</mybatis.version>
    <!--mysql-->
    <mysql.version>5.1.44</mysql.version>
    <!--pagehelper分页jar依赖-->
    <pagehelper.version>5.1.2</pagehelper.version>
    <!--mybatis与spring集成jar依赖-->
    <mybatis.spring.version>1.3.1</mybatis.spring.version>
    <!--3.dbcp2连接池相关 druid-->
    <commons.dbcp2.version>2.1.1</commons.dbcp2.version>
    <commons.pool2.version>2.4.3</commons.pool2.version>
    <!--4.log日志相关-->
    <log4j2.version>2.9.1</log4j2.version>
    <log4j2.disruptor.version>3.2.0</log4j2.disruptor.version>
    <slf4j.version>1.7.13</slf4j.version>
    <!--5.其他-->
    <junit.version>4.12</junit.version>
    <servlet.version>4.0.0</servlet.version>
    <lombok.version>1.18.2</lombok.version>
    <mybatis.ehcache.version>1.1.0</mybatis.ehcache.version>
    <ehcache.version>2.10.0</ehcache.version>
    <redis.version>2.9.0</redis.version>
    <redis.spring.version>1.7.1.RELEASE</redis.spring.version>
    <jackson.version>2.9.3</jackson.version>
    <jstl.version>1.2</jstl.version>
    <standard.version>1.1.2</standard.version>
    <tomcat-jsp-api.version>8.0.47</tomcat-jsp-api.version>
    <commons-fileupload.version>1.3.3</commons-fileupload.version>
    <hibernate-validator.version>5.0.2.Final</hibernate-validator.version>
    <shiro.version>1.3.2</shiro.version>
  </properties>
  <dependencies>
    <!--1.spring相关-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!--2.mybatis相关-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <!--pagehelper分页插件jar包依赖-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>${pagehelper.version}</version>
    </dependency>
    <!--mybatis与spring集成jar包依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis.spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!--mybatis与ehcache整合-->
    <dependency>
      <groupId>org.mybatis.caches</groupId>
      <artifactId>mybatis-ehcache</artifactId>
      <version>${mybatis.ehcache.version}</version>
    </dependency>
    <!--ehcache依赖-->
    <dependency>
      <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache</artifactId>
      <version>${ehcache.version}</version>
    </dependency>
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>${redis.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>${redis.spring.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <!--3.dbcp2连接池相关-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-dbcp2</artifactId>
      <version>${commons.dbcp2.version}</version>
      <exclusions>
        <exclusion>
          <artifactId>commons-pool2</artifactId>
          <groupId>org.apache.commons</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
      <version>${commons.pool2.version}</version>
    </dependency>
    <!--springmvc依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!--4.log日志相关依赖-->
    <!-- log4j2日志相关依赖 -->
    <!-- log配置：Log4j2 + Slf4j -->
    <!-- slf4j核心包-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jcl-over-slf4j</artifactId>
      <version>${slf4j.version}</version>
      <scope>runtime</scope>
    </dependency>
    <!--核心log4j2jar包-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <!--用于与slf4j保持桥接-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-slf4j-impl</artifactId>
      <version>${log4j2.version}</version>
    </dependency>
    <!--web工程需要包含log4j-web，非web工程不需要-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-web</artifactId>
      <version>${log4j2.version}</version>
      <scope>runtime</scope>
    </dependency>
    <!--需要使用log4j2的AsyncLogger需要包含disruptor-->
    <dependency>
      <groupId>com.lmax</groupId>
      <artifactId>disruptor</artifactId>
      <version>${log4j2.disruptor.version}</version>
    </dependency>
    <!--5.其他-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
<!--      <scope>test</scope>-->
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstl.version}</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>${standard.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.tomcat</groupId>
      <artifactId>tomcat-jsp-api</artifactId>
      <version>${tomcat-jsp-api.version}</version>
    </dependency>
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>${commons-fileupload.version}</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>${hibernate-validator.version}</version>
    </dependency>
    <!--shiro依赖-->
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-core</artifactId>
      <version>${shiro.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-web</artifactId>
      <version>${shiro.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-spring</artifactId>
      <version>${shiro.version}</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>CloudJunzySSM</finalName>
    <resources>
      <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
        </includes>
      </resource>
      <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>*.properties</include>
          <include>*.xml</include>
        </includes>
      </resource>
    </resources>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>${maven.compiler.plugin.version}</version>
          <configuration>
            <source>${maven.compiler.source}</source>
            <target>${maven.compiler.target}</target>
            <encoding>${project.build.sourceEncoding}</encoding>
          </configuration>
        </plugin>
        <plugin>
          <groupId>org.mybatis.generator</groupId>
          <artifactId>mybatis-generator-maven-plugin</artifactId>
          <version>1.3.2</version>
          <dependencies>
            <!--使用Mybatis-generator插件不能使用太高版本的mysql驱动 -->
            <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>${mysql.version}</version>
            </dependency>
          </dependencies>
          <configuration>
            <overwrite>true</overwrite>
          </configuration>
        </plugin>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
  </build>
</project>

创建配置文件 spring-context.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--    spring框架和mybatis进行整合的配置文件加载到spring的上下文中-->
<import resource="classpath:spring-mybatis.xml"></import>
</beans>

创建配置文件 spring-mybatis.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:tx="http://www.springframework.org/schema/tx"
       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 http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--1. 注解式开发 -->
    <!-- 注解驱动 -->
    <context:annotation-config/>
    <!-- 用注解方式注入bean，并指定查找范围：com.CloudJun及子子孙孙包-->
    <context:component-scan base-package="com.CloudJun"/>
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <!--初始连接数-->
        <property name="initialSize" value="10"/>
        <!--最大活动连接数-->
        <property name="maxTotal" value="100"/>
        <!--最大空闲连接数-->
        <property name="maxIdle" value="50"/>
        <!--最小空闲连接数-->
        <property name="minIdle" value="10"/>
        <!--设置为-1时，如果没有可用连接，连接池会一直无限期等待，直到获取到连接为止。-->
        <!--如果设置为N（毫秒），则连接池会等待N毫秒，等待不到，则抛出异常-->
        <property name="maxWaitMillis" value="-1"/>
    </bean>
    <!--4. spring和MyBatis整合 -->
    <!--1) 创建sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 指定数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 自动扫描XxxMapping.xml文件，**是任意路径 -->
        <property name="mapperLocations" value="classpath*:com/CloudJun/**/mapper/*.xml"/>
        <!-- 指定别名 -->
        <property name="typeAliasesPackage" value="com/CloudJun/**/model"/>
        <!--配置pagehelper插件-->
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <value>
                            helperDialect=mysql
                        </value>
                    </property>
                </bean>
            </array>
        </property>
    </bean>
    <!--2) 自动扫描com/CloudJun/**/mapper下的所有XxxMapper接口(其实就是DAO接口)，并实现这些接口，-->
    <!--   即可直接在程序中使用dao接口，不用再获取sqlsession对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--basePackage 属性是映射器接口文件的包路径。-->
        <!--你可以使用分号或逗号 作为分隔符设置多于一个的包路径-->
        <property name="basePackage" value="com/CloudJun/**/mapper"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager" />
    <aop:aspectj-autoproxy/>
</beans>

创建配置文件 spring-mvc.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:mvc="http://www.springframework.org/schema/mvc" 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
        http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <!--1) 扫描com.CloudJun及子子孙孙包下的控制器(扫描范围过大，耗时)-->
    <context:component-scan base-package="com.CloudJun"/>
    <!--2) 此标签默认注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->
    <mvc:annotation-driven />
    <!--3) 创建ViewResolver视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- viewClass需要在pom中引入两个包：standard.jar and jstl.jar -->
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--4) 单独处理图片、样式、js等资源 -->
    <!-- <mvc:resources location="/css/" mapping="/css/**"/>
     <mvc:resources location="/js/" mapping="/js/**"/>
     <mvc:resources location="WEB-INF/images/" mapping="/images/**"/>-->
    <!--   处理static包里的所有静态资源 -->
    <mvc:resources location="/static/" mapping="/static/**"/>
    <!-- 处理文件上传下载的资源   -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 必须和用户JSP 的pageEncoding属性一致，以便正确解析表单的内容 -->
        <property name="defaultEncoding" value="UTF-8"></property>
        <!-- 文件最大大小(字节) 1024*1024*50=50M-->
        <property name="maxUploadSize" value="52428800"></property>
        <!--resolveLazily属性启用是为了推迟文件解析，以便捕获文件大小异常-->
        <property name="resolveLazily" value="true"/>
    </bean>
<!--&lt;!&ndash;    &lt;!&ndash;配置自定义拦截器&ndash;&gt;&ndash;&gt;-->
<!--    <mvc:interceptors>-->
<!--        <bean class="com.CloudJun.Interceptor.OneInterceptor"></bean>-->
<!--    </mvc:interceptors>-->
<!--    &lt;!&ndash;2) 配置自定义多拦截器（拦截器链）&ndash;&gt;-->
<!--    <mvc:interceptors>-->
<!--    &lt;!&ndash;    拦截所以有用请求地址   &ndash;&gt;-->
<!--        <mvc:interceptor>-->
<!--            <mvc:mapping path="/**"/>-->
<!--            <bean class="com.CloudJun.Interceptor.OneInterceptor"/>-->
<!--        </mvc:interceptor>-->
<!--        &lt;!&ndash;    只拦截中间有用名为clz的请求地址   &ndash;&gt;-->
<!--        <mvc:interceptor>-->
<!--            <mvc:mapping path="/hot/**"/>-->
<!--            <bean class="com.CloudJun.Interceptor.TwoInterceptor"/>-->
<!--        </mvc:interceptor>-->
<!--    </mvc:interceptors>-->
<!--&lt;!&ndash;    用户权限的请求拦截&ndash;&gt;-->
<!--    <mvc:interceptors>-->
<!--        <bean class="com.CloudJun.Interceptor.LoginInterceptor"></bean>-->
<!--    </mvc:interceptors>-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>
    <bean id="mappingJackson2HttpMessageConverter"
          class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <!--处理中文乱码以及避免IE执行AJAX时，返回JSON出现下载文件-->
        <property name="supportedMediaTypes">
            <list>
                <value>text/html;charset=UTF-8</value>
                <value>text/json;charset=UTF-8</value>
                <value>application/json;charset=UTF-8</value>
            </list>
        </property>
    </bean>
    <!-- springmvc提供的简单异常处理器 -->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <!-- 定义默认的异常处理页面 -->
        <property name="defaultErrorView" value="error"/>
        <!-- 定义异常处理页面用来获取异常信息的变量名，也可不定义，默认名为exception -->
        <property name="exceptionAttribute" value="ex"/>
        <!-- 定义需要特殊处理的异常，这是重要点 -->
        <property name="exceptionMappings">
            <props>
                <prop key="java.lang.RuntimeException">error</prop>
            </props>
            <!-- 还可以定义其他的自定义异常 -->
        </property>
    </bean>
    <!--处理controller层发送请求到biz层，会经过切面拦截处理-->
    <aop:aspectj-autoproxy/>
</beans>

也可以不进行以上配置及导入，一下是基于我博客中代码进行知识点扩展

SpringMVC之JSON数据返回及异常处理机制

重写创建的项目才需要导入以上引用及配置

场景一（获取类与方法上的注解值）

创建 TranscationModel 直接C到包里接口

package com.CloudJun.annotation;
public enum  TranscationModel {
    Read, Write, ReadWrite
}

创建 MyAnnotation1 直接C到包里接口

package com.CloudJun.annotation;
import java.lang.annotation.*;
/**
 * @author CloudJun
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
//@Inherited //继承使用需要该注解，否则读取不到已继承的注解及属性
@Documented
public @interface MyAnnotation1 {
    String name();
}

创建 MyAnnotation2 直接C到包里接口

package com.CloudJun.annotation;
import java.lang.annotation.*;
/**
 * @author CloudJun
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}

创建 MyAnnotation3 直接C到包里接口

package com.CloudJun.annotation;
import java.lang.annotation.*;
/**
 * @author CloudJun
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}

创建测试类进行自定义注解测试 Demo1

package com.CloudJun.annotation.Demo1;
import com.CloudJun.annotation.MyAnnotation1;
import com.CloudJun.annotation.MyAnnotation2;
import com.CloudJun.annotation.MyAnnotation3;
import com.CloudJun.annotation.TranscationModel;
/**
 * @author CloudJun
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "Cloud")
public class Demo1 {
    @MyAnnotation1(name = "Jun")
    private Integer age;
    @MyAnnotation2(model = TranscationModel.Read)
    public void list() {
        System.out.println("list");
    }
    @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    public void edit() {
        System.out.println("edit");
    }
}

创建测试类进行自定义注解测试 Demo1Test

package com.CloudJun.annotation.Demo1;
import com.CloudJun.annotation.MyAnnotation1;
import com.CloudJun.annotation.MyAnnotation2;
import com.CloudJun.annotation.MyAnnotation3;
import com.CloudJun.annotation.TranscationModel;
import org.junit.Test;
/**
 * @author CloudJun
 */
public class Demo1Test {
    @Test
    public void list() throws Exception {
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo2.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//Cloud
//        获取方法上的注解
        MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
        System.out.println(myAnnotation2.model());//Read
//        获取属性上的注解
        MyAnnotation1 myAnnotation1 = Demo1.class.getDeclaredField("age").getAnnotation(MyAnnotation1.class);
        System.out.println(myAnnotation1.name());// Jun
    }
    @Test
    public void edit() throws Exception {
        MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
        for (TranscationModel model : myAnnotation3.models()) {
            System.out.println(model);//Read,Write
        }
    }
}

执行其中的方法（ list ）进行测试，输出结果如下 :

执行其中的方法（ edit）进行测试，输出结果如下 :

场景二（获取类属性上的注解属性值）

场景自定义注解 TestAnnotation

package com.CloudJun.annotation.Demo2;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * @author CloudJun
 */
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";
    String what() default "这里是默认的what属性对应的值";
}

创建测试类进行自定义注解的测试 Demo2

package com.CloudJun.annotation.Demo2;
/**
 * @author CloudJun
 * 获取类属性上的注解属性值
 */
public class Demo2 {
    @TestAnnotation(value = "这里是value对应的值--msg1", what = "这里是what对应的值--msg1")
    private static String msg1;
    @TestAnnotation("这就是value对应的值==pa")
    private static String msg2;
    @TestAnnotation(value = "这就是value对应的值==as")
    private static String msg3;
    @TestAnnotation(what = "这就是what对应的值")
    private static String msg4;
}

创建测试类进行自定义注解的测试 Demo2Test

package com.CloudJun.annotation.Demo2;
import org.junit.Test;
/**
 * @author CloudJun
 * 1.value--默认值
 * 2.default--默认值的赋予
 */
public class Demo2Test {
    @Test
    public void test1() throws Exception {
        TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
        System.out.println(msg1.value());
        System.out.println(msg1.what());
    }
    @Test
    public void test2() throws Exception{
        TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
        System.out.println(msg2.value());
        System.out.println(msg2.what());
    }
    @Test
    public void test3() throws Exception{
        TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
        System.out.println(msg3.value());
        System.out.println(msg3.what());
    }
    @Test
    public void test4() throws Exception{
        TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
        System.out.println(msg4.value());
        System.out.println(msg4.what());
    }
}

执行其中 test1 的方法进行测试，输出结果为 :

执行其中 test2 的方法进行测试，输出结果为 :

执行其中 test3 的方法进行测试，输出结果为 :

执行其中 test4 的方法进行测试，输出结果为 :

场景三（获取参数修饰注解对应的属性值）

创建自定义注解 IsNotNull

package com.CloudJun.annotation.Demo3;
import java.lang.annotation.*;
/**
 * @author CloudJun
 * 非空注解：
 * 使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

创建测试类 Demo3

package com.CloudJun.annotation.Demo3;
/**
 * @author CloudJun
 * 获取参数修饰注解对应的属性值
 */
public class Demo3 {
    public void hello1(@IsNotNull(true) String name) {
        System.out.println("hello:" + name);
    }
    public void hello2(@IsNotNull String name) {
        System.out.println("hello:" + name);
    }
}

创建测试类 Demo3Test进行方法测试

package com.CloudJun.annotation.Demo3;
import org.junit.Test;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
/**
 * @author CloudJun
 */
public class Demo3Test {
    @Test
    public void hello1() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                //如果值没有设置，将会是默认值为:false
                System.out.println(annotation.value());//true
            }
        }
    }
    @Test
    public void hello2() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                //如果值有设置，将会是默认值为:true
                System.out.println(annotation.value());//false
            }
        }
    }
    @Test
    public void hello3() throws Exception {
//        模拟浏览器传递到后台的参数 解读@requestParam
        String name = "独孤九剑";
        Demo3 demo3 = new Demo3();
        Method method = demo3.getClass().getMethod("hello1", String.class);
        for (Parameter parameter : method.getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
                if (annotation.value() && !"".equals(name)){
                    method.invoke(demo3,name);
                }
            }
        }
    }
}

执行其中的方法( hello1 )进行测试，输出结果为 :

执行其中的方法( hello2 )进行测试，输出结果为 :

执行其中的方法( hello3 )进行测试，输出结果为 :

三、Aop自定义注解的应用

AOP（面向切面编程）是一种编程范式，它通过在程序运行时动态地将额外的逻辑织入到方法或类中，从而实现对方法或类的增强。自定义注解可以与AOP结合使用，用于标记需要进行增强的方法或类。

以下是一个示例，演示了如何使用自定义注解与AOP结合，实现日志记录的功能：

1 .定义自定义注解@MyLog，用于标记需要记录日志的方法：

package com.CloudJun.annotation.aop;
        import java.lang.annotation.ElementType;
        import java.lang.annotation.Retention;
        import java.lang.annotation.RetentionPolicy;
        import java.lang.annotation.Target;
/**
 * @author CloudJun
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

2 . 定义切面类MyLogAspect，在该类中定义增强逻辑，例如记录日志：

package com.CloudJun.aspect;
import com.CloudJun.annotation.aop.MyLog;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
 * @author CloudJun
 */
@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
    /**
     * 只要用到了com.CloudJun.annotation.aop.MyLog这个注解的，就是目标类
     * 是目标类就会执行以下before方法里的代码
     */
    @Pointcut("@annotation(com.CloudJun.annotation.aop.MyLog)")
    private void MyValid() {
    }
    @Before("MyValid()")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        logger.debug("[" + signature.getName() + " : start.....]");
        System.out.println("[" + signature.getName() + " : start.....]");
        MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
        logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
        System.out.println("【目标对象方法被调用时候产生的日志，记录到日志表中】：" + myLog.desc());
    }
//    @Around("MyValid()")
//    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
//        long startTime = System.currentTimeMillis();
//        System.out.println(pjp.getTarget());//获取目标方法
//        System.out.println(pjp.getThis());//
//        Object[] args = pjp.getArgs();//获取参数
//        System.out.println(Arrays.toString(args));//输出参数
//        Object ob = pjp.proceed();//获取方法返回值
//        System.out.println(ob);//输出返回值
//        logger.info("耗时 : " + (System.currentTimeMillis() - startTime));
//        return ob;
//    }
}

在上面的切面类中，使用@Aspect注解标记该类为切面类。@Pointcut("@annotation(com.CloudJun.annotation.aop.MyLog)")注解用于定义切点，表示匹配所有标记有@Log注解的方法。@Before注解表示在目标方法执行前执行增强逻辑。

3 . 创建一个控制器 LogController

package com.CloudJun.web;
import com.CloudJun.annotation.aop.MyLog;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
/**
 * @author CloudJun
 */
@Controller
public class LogController {
    @RequestMapping("/myLog")
    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    public void testLogAspect(HttpServletRequest request){
        request.getRemoteAddr();//这里是获取请求IP,可以输出或者保存在某个地方及属性
        request.getRemotePort();//这里是获取请求端口,可以输出或者保存在某个地方及属性
        System.out.println("这里随便来点啥");
    }
}

自定义注解与AOP结合使用，可以实现各种不同的功能，如权限控制、性能监控、事务管理等。根据具体的业务需求，可以定义不同的注解，并在切面类中实现相应的增强逻辑。

测试

开启服务器，在浏览器中进行访问地址，进行测试( 以下访问地址是根据自己配置而修改的 )

访问该地址进行测试 : localhost:8081/ssm/

myLog ( 结果如下 )

将切面类中( MyLogAspect ) 的 before 方法进行注释，将其中的 doAround 方法注释打开

同样访问该地址进行测试 : localhost:8081/ssm/myLog ( 结果如下 )

小总结

通过自定义注解与AOP结合使用，可以实现各种不同的功能，根据具体的业务需求进行定制化开发。这种方式可以将横切逻辑与业务逻辑分离，提高代码的可维护性和可扩展性，同时也减少了代码的重复编写。

带给我们的收获

学习SpringMVC中的自定义注解和AOP自定义注解的应用可以带来以下几个方面的收获：

1. 提高代码重用性：通过自定义注解，我们可以将一些常用的功能逻辑抽象为注解，然后在需要的地方进行标记和使用。这样可以减少代码的重复编写，提高代码的可维护性和可读性。

2. 简化开发流程：通过自定义注解，我们可以简化一些繁琐的配置和操作。比如，在SpringMVC中，我们可以使用自定义注解来标记控制器的映射路径，从而省去手动配置URL映射的步骤，简化了开发流程。

3. 实现横切关注点：AOP（面向切面编程）可以通过自定义注解来实现横切关注点的功能，例如日志记录、事务管理、权限控制等。通过在代码中标记自定义注解，可以将这些关注点与业务逻辑分离，提高代码的可维护性和可扩展性。

4. 代码解耦和模块化：通过自定义注解和AOP，我们可以将一些功能逻辑和横切关注点从业务代码中解耦出来，实现模块化的开发。这样可以降低代码的耦合度，提高代码的可测试性和可维护性。

总的来说，学习SpringMVC中的自定义注解和AOP自定义注解的应用，可以提高代码的重用性、简化开发流程，实现横切关注点，解耦业务代码，从而带来更加高效、可维护和可扩展的代码开发和管理。

学会SpringMVC之自定义注解各种场景应用，提高开发效率及代码质量

一、简介

( 1 ) 是什么

( 2 ) 分类

( 3 ) 作用

二、自定义注解

( 1 ) 如何自定义注解

( 2 ) 场景演示

场景一（获取类与方法上的注解值）

场景二（获取类属性上的注解属性值）

场景三（获取参数修饰注解对应的属性值）

三、Aop自定义注解的应用

带给我们的收获

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

学会SpringMVC之自定义注解各种场景应用，提高开发效率及代码质量

一、简介

( 1 ) 是什么

( 2 ) 分类

( 3 ) 作用

二、自定义注解

( 1 ) 如何自定义注解

( 2 ) 场景演示

场景一（获取类与方法上的注解值）

场景二（ 获取类属性上的注解属性值）

场景三（ 获取参数修饰注解对应的属性值）

三、Aop自定义注解的应用

带给我们的收获

热门文章

最新文章

相关课程

相关电子书

场景二（获取类属性上的注解属性值）

场景三（获取参数修饰注解对应的属性值）