四、注解开发

在spring4之后，想要使用注解形式，必须得要引入aop的包（spring-webmvc已导入，无需再次导入spring-aop包）

在配置文件当中，需要引入一个context约束：

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

然后在bean中配置：

<!-- 开启注解的支持 -->
<context:annotation-config/>
<!-- 指定扫描的包 -->
<context:component-scan base-package="com.rui"/>

常见的注解有：

• Bean实现 -> @Component
• 注入属性 -> @Value
• 衍生注解 -> @Controller：web层、@Service：service层、@Repository：dao层
• 自动装配 -> @Autowired、@Qualifier、@Resource
• JavaConfig -> @Configuration、@ComponentScan、@Import

4.1、Bean实现

1、配置扫描哪些包下的注解

<!--指定注解扫描包-->
<context:component-scan base-package="com.rui.pojo"/>

2、在指定包下编写类，增加注解

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {public String name = "xiaoming";
}

4.2、注入属性

使用注解注入属性

1、可以不用提供set方法，直接在直接名上添加@value(“值”)

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {@Value("xiaoming")// 相当于配置文件中 <property name="name" value="秦疆"/>public String name;
}

2、如果提供了set方法，也可以在set方法上添加@value(“值”);

@Component("user")
public class User {public String name;@Value("xiaoming")public void setName(String name) {this.name = name;}
}

4.3、衍生注解

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

• @Controller：web层
• @Service：service层
• @Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！

其他注解

• @scope作用域

@Controller("user")
@Scope("prototype")
public class User {@Value("xiaoming")public String name;
}

• @Autowired、@Qualifier、@Resource自动装配注解，见下

4.4、自动装配

• @Autowired按类型自动转配的
• @Qualifier根据byName的方式自动装配
• @Resource兼顾两者自动装配方式

1、在spring配置文件中引入context文件头

xmlns:context="http://www.springframework.org/schema/context"http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2、开启属性注解支持！

<context:annotation-config/>

@Autowired

注：需要导入 spring-aop的包！

测试：

1、将User类中的set方法去掉，使用@Autowired注解

public class User {@Autowiredprivate Cat cat;@Autowiredprivate Dog dog;private String str;public Cat getCat() {return cat;}public Dog getDog() {return dog;}public String getStr() {return str;}
}

2、此时配置文件内容

<!-- 开启属性注解支持！ -->
<context:annotation-config/><bean id="dog" class="com.rui.pojo.Dog"/>
<bean id="cat" class="com.rui.pojo.Cat"/>
<bean id="user" class="com.rui.pojo.User"/>

拓展：@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

//如果允许对象为null，设置required = false,默认为true
@Autowired(required = false)

@Qualifier

• @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配

• @Qualifier不能单独使用。

测试实验步骤：

1、配置文件修改内容，保证类型存在对象。且名字不为类的默认名字！

<bean id="dog1" class="com.kuang.rui.Dog"/>
<bean id="dog2" class="com.kuang.rui.Dog"/>
<bean id="cat1" class="com.kuang.rui.Cat"/>
<bean id="cat2" class="com.kuang.rui.Cat"/>

2、没有加Qualifier测试，直接报错

3、在属性上添加Qualifier注解

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

测试，成功输出！

@Resource

• @Resource如有指定的name属性，先按该属性进行byName方式查找装配；
• 其次再进行默认的byName方式进行装配；
• 如果以上都不成功，则按byType的方式自动装配。
• 都不成功，则报异常。

实体类：

public class User {//如果允许对象为null，设置required = false,默认为true@Resource(name = "cat2")private Cat cat;@Resourceprivate Dog dog;private String str;
}

beans.xml

<bean id="dog" class="com.rui.pojo.Dog"/>
<bean id="cat1" class="com.rui.pojo.Cat"/>
<bean id="cat2" class="com.rui.pojo.Cat"/><bean id="user" class="com.rui.pojo.User"/>

测试：结果OK

配置文件2：beans.xml ， 删掉cat2

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>

实体类上只保留注解

@Resource
private Cat cat;
@Resource
private Dog dog;

结论：先进行byName查找，失败；再进行byType查找，成功。

自动装配注解开发小结：

@Autowired与@Resource异同：

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

4.5、JavaConfig

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。

测试：

1、编写一个实体类，Dog

@Component  //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {public String name = "dog";
}

2、新建一个config配置包，编写一个MyConfig配置类

@Configuration  //这是一个配置类，类似beans.xml
@ComponentScan("com.rui.pojo")
public class MyConfig {@Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！public Dog dog(){return new Dog();}}

3、测试

@Test
public void test2(){ApplicationContext applicationContext =new AnnotationConfigApplicationContext(MyConfig.class);Dog dog = (Dog) applicationContext.getBean("dog");System.out.println(dog.name);
}

4、成功输出结果！

导入其他配置如何做呢？

1、我们再编写一个配置类！

@Configuration  //这是一个配置类，类似beans.xml
public class MyConfig2 {
}

2、在之前的配置类中我们来选择导入这个配置类

@Configuration
@Import(MyConfig2.class)  //导入合并其他配置类，类似于配置文件中的 inculde 标签
public class MyConfig {@Beanpublic Dog dog(){return new Dog();}}

关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道这些注解的作用即可！

五、AOP

5.1、简介

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

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

5.1.1、AOP的主要角色

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

5.1.2、Advice的主要类型

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

通知类型	连接点	实现接口	注解
前置通知	方法方法前	org.springframework.aop.MethodBeforeAdvice	@Before
后置通知	方法后	org.springframework.aop.AfterReturningAdvice	@AfterRunning
环绕通知	方法前后	org.aopalliance.intercept.MethodInterceptor	@Around
异常抛出通知	方法抛出异常	org.springframework.aop.ThrowsAdvice	@AfterThrowing
引介通知	类中增加新的方法属性	org.springframework.aop.IntroductionAdvisor

注：@Before是业务逻辑执行前执行，与其对应的是@AfterReturning，而不是@After，@After是所有的切面逻辑执行完之后才会执行，无论是否抛出异常。

5.1.3、切点表达式

在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点"

例如定义切入点表达式 execution (* com.sample.service.impl…*.*(…))

execution()是最常用的切点函数，其语法如下所示：

整个表达式可以分为五个部分：

1、execution(): 表达式主体。

2、第一个*号：表示返回类型， *号表示所有的类型。

3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。

4、第二个* 号：表示类名，*号表示所有的类。

5、(…):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。

更多的Aop表达式可参考Spring AOP切点表达式用法总结 - 博客园

5.2、Spring实现Aop的三种方式

【重点】使用AOP织入，需要在pom.xml导入一个依赖包！

<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.7</version>
</dependency>

5.2.1、通过 Spring API 实现

首先编写我们的业务接口和实现类

public interface UserService {public void add();public void delete();public void update();public void search();}
public class UserServiceImpl implements UserService{@Overridepublic void add() {System.out.println("增加用户");}@Overridepublic void delete() {System.out.println("删除用户");}@Overridepublic void update() {System.out.println("更新用户");}@Overridepublic void search() {System.out.println("查询用户");}
}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强

public class BeforeLog implements MethodBeforeAdvice {//method : 要执行的目标对象的方法//objects : 被调用的方法的参数//Object : 目标对象@Overridepublic void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");}
}
public class AfterLog implements AfterReturningAdvice {//returnValue 返回值//method被调用的方法//args 被调用的方法的对象的参数//target 被调用的目标对象@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("执行了" + target.getClass().getName()+"的"+method.getName()+"方法,"+"返回值："+returnValue);}
}

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!--注册bean--><bean id="userService" class="com.rui.service.UserServiceImpl"/><bean id="beforelog" class="com.rui.log.BeforeLog"/><bean id="afterLog" class="com.rui.log.AfterLog"/><!--aop的配置--><aop:config><!--切入点 expression:表达式匹配要执行的方法--><aop:pointcut id="pointcut" expression="execution(* com.rui.service.UserServiceImpl.*(..))"/><!--执行环绕; advice-ref执行方法 . pointcut-ref切入点--><aop:advisor advice-ref="beforelog" pointcut-ref="pointcut"/><aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/></aop:config></beans>

测试

public class MyTest {@Testpublic void test(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");UserService userService = (UserService) context.getBean("userService");userService.search();}
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

5.2.2、自定义类来实现

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

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

去spring中配置

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.rui.config.DiyPointcut"/><!--aop的配置-->
<aop:config><!--第二种方式：使用AOP的标签实现--><aop:aspect ref="diy"><aop:pointcut id="diyPonitcut" expression="execution(* com.rui.service.UserServiceImpl.*(..))"/><aop:before pointcut-ref="diyPonitcut" method="before"/><aop:after pointcut-ref="diyPonitcut" method="after"/></aop:aspect>
</aop:config>

测试：

public class MyTest {@Testpublic void test(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");UserService userService = (UserService) context.getBean("userService");userService.add();}
}

5.2.3、使用注解实现

第一步：编写一个注解实现的增强类

package com.rui.config;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;@Aspect
public class AnnotationPointcut {@Before("execution(* com.kuang.service.UserServiceImpl.*(..))")public void before(){System.out.println("---------方法执行前---------");}@After("execution(* com.kuang.service.UserServiceImpl.*(..))")public void after(){System.out.println("---------方法执行后---------");}@Around("execution(* com.kuang.service.UserServiceImpl.*(..))")public void around(ProceedingJoinPoint jp) throws Throwable {System.out.println("环绕前");System.out.println("签名:"+jp.getSignature());//执行目标方法proceedObject proceed = jp.proceed();System.out.println("环绕后");System.out.println(proceed);}
}

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.rui.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：说明

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy poxy-target-class=“true”/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

Spring学习笔记均参考于“狂神说”