spring学习笔记（二）

Spring的Bean管理:(注解方式)

Spring的AOP：XML方式

Spring的AOP：注解方式

1、Spring的Bean管理的中常用的注解:

* @Controller   :WEB层

* @Service      :业务层

* @Repository   :持久层

1.1、 @Component:组件.(作用在类上)

Spring中提供@Component的三个衍生注解:(功能目前来讲是一致的)

　　* @Controller   :WEB层

　　* @Service      :业务层

　　* @Repository   :持久层

 

这三个注解是为了让标注类本身的用途清晰，Spring在后续版本会对其增强

1.1.1、属性注入的注解:(使用注解注入的方式,可以不用提供set方法.)

@Value      :用于注入普通类型.

@Autowired  :自动装配:

　　* 默认按类型进行装配.

　　* 按名称注入:

　　　　* @Qualifier:强制使用名称注入.

@Resource相当于:

　　　　* @Autowired和@Qualifier一起使用.

1.1.2、  Bean的作用范围的注解:

@Scope:

　　* singleton:单例

　　* prototype:多例

1.1.3、Bean的生命周期的配置:

@PostConstruct  :相当于init-method

@PreDestroy     :相当于destroy-method

1.2、开启注解扫描

https://blog.csdn.net/u014427391/article/details/72722797

Spring框架对Bean进行装配提供了很灵活的方式，下面归纳一下主要的方式：
• 在XML中进行显示配置
• 在Java中进行显示配置
• 隐式的bean发现机制和自动装配

而自动装配实现就需要注解扫描，这时发现了两种开启注解扫描的方式，即<context:annotation-config/>和<context:component-scan>
下面归纳一下这两种方式的异同点：

<context:annotation-config>:注解扫描是针对已经在Spring容器里注册过的Bean

<context:component-scan>:不仅具备<context:annotation-config>的所有功能，还可以在指定的package下面扫描对应的bean

2、Spring的Bean管理的方式的比较:

XML和注解:

　　* XML   :结构清晰.

　　* 注解   :开发方便.(属性注入.)

实际开发中还有一种XML和注解整合开发:

　　* Bean有XML配置.但是使用的属性使用注解注入.

3、AOP概述

Spring是解决实际开发中的一些问题:

* AOP解决OOP中遇到的一些问题.是OOP的延续和扩展.

AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.

3.1、aop优势

对程序进行增强:不修改源码的情况下.

　　* AOP可以进行权限校验,日志记录,性能监控,事务控制.

3.2、底层实现

代理机制:

* Spring的AOP的底层用到两种代理机制：

　　  * JDK的动态代理   :针对实现了接口的类产生代理.

　　 * Cglib的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类的子类对象.

3.2.1、JDK动态代理增强一个类中方法:

public class MyJDKProxy implements InvocationHandler {

    private UserDao userDao;

    public MyJDKProxy(UserDao userDao) {
        this.userDao = userDao;
    }

    // 编写工具方法：生成代理：
    public UserDao createProxy(){
        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
                userDao.getClass().getInterfaces(), this);

        return userDaoProxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("save".equals(method.getName())){
            System.out.println("权限校验================");
        }
        return method.invoke(userDao, args);
    }
}

3.2.2、Cglib动态代理增强一个类中的方法:

public class MyCglibProxy implements MethodInterceptor{

    private CustomerDao customerDao;

    public MyCglibProxy(CustomerDao customerDao){
        this.customerDao = customerDao;
    }

    // 生成代理的方法:
    public CustomerDao createProxy(){
        // 创建Cglib的核心类:
        Enhancer enhancer = new Enhancer();
        // 设置父类:
        enhancer.setSuperclass(CustomerDao.class);
        // 设置回调:
        enhancer.setCallback(this);
        // 生成代理：
        CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();
        return customerDaoProxy;
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        if("delete".equals(method.getName())){
            Object obj = methodProxy.invokeSuper(proxy, args);
            System.out.println("日志记录================");
            return obj;
        }

        return methodProxy.invokeSuper(proxy, args);
    }
}

4、Spring的基于AspectJ的AOP开发

4.1、  AOP的开发中的相关术语:

Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.

Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.

Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

Target(目标对象):代理的目标对象

Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.

spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入

Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面): 是切入点和通知（引介）的结合

5、AOP：XML方式

导入包

* spring的传统AOP的开发的包

　　spring-aop-4.2.4.RELEASE.jar

　　com.springsource.org.aopalliance-1.0.0.jar

* aspectJ的开发包:

　　com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

　　spring-aspects-4.2.4.RELEASE.jar

5.1、引入配置文件

引入AOP约束:

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

</beans>

5.2、编写目标类

创建接口和类:

public interface OrderDao {
    public void save();
    public void update();
    public void delete();
    public void find();
}

public class OrderDaoImpl implements OrderDao {

    @Override
    public void save() {
        System.out.println("保存订单...");
    }

    @Override
    public void update() {
        System.out.println("修改订单...");
    }

    @Override
    public void delete() {
        System.out.println("删除订单...");
    }

    @Override
    public void find() {
        System.out.println("查询订单...");
    }

}

5.3、  目标类的配置

    <!-- 目标类================ -->
    <bean id="orderDao" class="cn.xxxxxx.spring.demo3.OrderDaoImpl">

    </bean>

5.4、 整合Junit单元测试

引入spring-test.jar

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {
    @Resource(name="orderDao")
    private OrderDao orderDao;

    @Test
    public void demo1(){
        orderDao.save();
        orderDao.update();
        orderDao.delete();
        orderDao.find();
    }
}

5.5、 通知类型

前置通知 ：在目标方法执行之前执行.

后置通知 ：在目标方法执行之后执行

环绕通知 ：在目标方法执行前和执行后执行

异常抛出通知：在目标方法执行出现 异常的时候 执行

最终通知 ：无论目标方法是否出现异常 最终通知都会 执行.

5.6、  切入点表达式

execution(表达式)

表达式:

[方法访问修饰符] 方法返回值 包名.类名.方法名(方法的参数)

public * cn.xxxxxx.spring.dao.*.*(..)

* cn.xxxxxx.spring.dao.*.*(..)

* cn.xxxxxx.spring.dao.UserDao+.*(..)

* cn.xxxxxx.spring.dao..*.*(..)

5.7、编写一个切面类

public class MyAspectXml {
    // 前置增强
    public void before(){
        System.out.println("前置增强===========");
    }
}

5.8、配置完成增强

<!-- 配置切面类 -->
    <bean id="myAspectXml" class="cn.xxxxxx.spring.demo3.MyAspectXml"></bean>

    <!-- 进行aop的配置 -->
    <aop:config>
        <!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
        <aop:pointcut expression="execution(* cn.xxxxxx.spring.demo3.OrderDao.save(..))" id="pointcut1"/>
        <!-- 配置切面 -->
        <aop:aspect ref="myAspectXml">
            <aop:before method="before" pointcut-ref="pointcut1"/>
        </aop:aspect>
    </aop:config>

5.9、其他的增强的配置

<!-- 配置切面类 -->
    <bean id="myAspectXml" class="cn.xxxxxx.spring.demo3.MyAspectXml"></bean>

    <!-- 进行aop的配置 -->
    <aop:config>
        <!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
        <aop:pointcut expression="execution(* cn.xxxxxx.spring.demo3.*Dao.save(..))" id="pointcut1"/>
        <aop:pointcut expression="execution(* cn.xxxxxx.spring.demo3.*Dao.delete(..))" id="pointcut2"/>
        <aop:pointcut expression="execution(* cn.xxxxxx.spring.demo3.*Dao.update(..))" id="pointcut3"/>
        <aop:pointcut expression="execution(* cn.xxxxxx.spring.demo3.*Dao.find(..))" id="pointcut4"/>
        <!-- 配置切面 -->
        <aop:aspect ref="myAspectXml">
            <aop:before method="before" pointcut-ref="pointcut1"/>
            <aop:after-returning method="afterReturing" pointcut-ref="pointcut2"/>
            <aop:around method="around" pointcut-ref="pointcut3"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>
            <aop:after method="after" pointcut-ref="pointcut4"/>
        </aop:aspect>
    </aop:config>

6、AOP：注解方式

* spring的传统AOP的开发的包

　　spring-aop-4.2.4.RELEASE.jar

　　com.springsource.org.aopalliance-1.0.0.jar

* aspectJ的开发包:

　　com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

　　spring-aspects-4.2.4.RELEASE.jar

6.1、引入Spring的配置文件

引入AOP约束:

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

</beans>

6.2、编写目标类:

public class ProductDao {
    public void save(){
        System.out.println("保存商品...");
    }
    public void update(){
        System.out.println("修改商品...");
    }
    public void delete(){
        System.out.println("删除商品...");
    }
    public void find(){
        System.out.println("查询商品...");
    }
}

6.3、  配置目标类：

 <!-- 目标类============ -->
     <bean id="productDao" class="cn.xxxxx.spring.demo4.ProductDao"></bean>   

6.4、 开启aop注解的自动代理:

<aop:aspectj-autoproxy/>

6.5、AspectJ的AOP的注解:

@Aspect:定义切面类的注解

通知类型:

　　 * @Before           :前置通知

　　  * @AfterReturing    :后置通知

　　 * @Around           :环绕通知

　　 * @After            :最终通知

　　 * @AfterThrowing    :异常抛出通知.

@Pointcut:定义切入点的注解

6.6、 编写切面类:

@Aspect
public class MyAspectAnno {

    @Before("MyAspectAnno.pointcut1()")
    public void before(){
        System.out.println("前置通知===========");
    }

    @Pointcut("execution(* cn.xxxxx.spring.demo4.ProductDao.save(..))")
    private void pointcut1(){}
}

6.7、配置切面:

<!-- 配置切面类 -->
     <bean id="myAspectAnno" class="cn.xxxxx.spring.demo4.MyAspectAnno"></bean>  

6.8、其他通知的注解:

@Aspect
public class MyAspectAnno {

    @Before("MyAspectAnno.pointcut1()")
    public void before(){
        System.out.println("前置通知===========");
    }

    @AfterReturning("MyAspectAnno.pointcut2()")
    public void afterReturning(){
        System.out.println("后置通知===========");
    }

    @Around("MyAspectAnno.pointcut3()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("环绕前通知==========");
        Object obj = joinPoint.proceed();
        System.out.println("环绕后通知==========");
        return obj;
    }

    @AfterThrowing("MyAspectAnno.pointcut4()")
    public void afterThrowing(){
        System.out.println("异常抛出通知========");
    }

    @After("MyAspectAnno.pointcut4()")
    public void after(){
        System.out.println("最终通知==========");
    }

    @Pointcut("execution(* cn.xxxxx.spring.demo4.ProductDao.save(..))")
    private void pointcut1(){}
    @Pointcut("execution(* cn.xxxxx.spring.demo4.ProductDao.update(..))")
    private void pointcut2(){}
    @Pointcut("execution(* cn.xxxxx.spring.demo4.ProductDao.delete(..))")
    private void pointcut3(){}
    @Pointcut("execution(* cn.xxxxx.spring.demo4.ProductDao.find(..))")
    private void pointcut4(){}
}