Spring（二）

Spring的Bean管理（注解方式）

导入包

在Spring的注解AOP中需要导入spring-aop的jar包

image.png

引入约束

image.png

快速入门

编写一个UserDao的接口

package com.cuzz;

public interface UserDao {
    public void sayHello();
}

编写一个UserDao接口的实现类

package com.cuzz;

public class UserDaoImpl implements UserDao {
    @Override
    public void sayHello() {
        System.out.println("Hello Spring...");
    }
}

在applicationContext.xml配置
Spring的注解开发：组件扫描

<context:component-scan base-package="com.cuzz" />

在类中添加注解

package com.cuzz;

import org.springframework.stereotype.Component;

@Component(value="userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void sayHello() {
        System.out.println("Hello Spring Annotation...");
    }
}

测试

package com.cuzz;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class TestDemo {
    @Test
    public void fun1() {
        // 创建spring工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过工厂解析xml获取Bean的实例
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.sayHello();   // 输出 Hello Spring Annotation...
    }
}

Bean管理的常用注解

类注解

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

@Controller ：WEB 层
@Service ：业务层
@Repository ：持久层
这三个注解是为了让标注类本身的用途清晰

Spring 属性注入的注解

@Value ：用于注入普通类型.
@Autowired ：自动装配，默认按类型进行装配.
@Qualifier：强制使用名称注入.
@Resource ：相当于@Autowired 和@Qualifier 一起使用

Bean 的作用范围的注解

@Scope(singleton)：单例
@Scope(prototype)：多例

Bean的生命周期的配置

@PostConstruct ：相当于 init-method
@PreDestroy ：相当于 destroy-method

代码演示

配置扫描路径

<context:component-scan base-package="com.cuzz.pojo" />

编写一个Car类

package com.cuzz.pojo;

import org.springframework.stereotype.Component;

@Component("car")
public class Car {
    
    private String name;
    private Integer price;
    
    public Car() {
        super();
    }
    
    public Car(String name, Integer price) {
        super();
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car [name=" + name + ", price=" + price + "]";
    }
}

编写一个User类

package com.cuzz.pojo;

import javax.annotation.Resource;

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

@Component("user")
// @Service("user") service层
// @Controller("user") web层
// @Repository("user") dao层
public class User {
    private String name;

    @Value("18")
    private Integer age;

    // 自动装配
    // @Autowired
    @Resource(name="car")
    private Car car;
    
    public User() {
        super();
    }
    
    public User(String name, Integer age, Car car) {
        super();
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
    }
}

测试

package com.cuzz.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cuzz.pojo.User;

public class TestDemo {
    @Test
    public void fun1() {
        // 创建spring工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过工厂解析xml获取Bean的实例
        User user = (User) applicationContext.getBean("user");
        System.out.println(user);
    }
}

注解测试
导入spring-test包spring-test-4.2.4.RELEASE.jar

package com.cuzz.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.cuzz.pojo.User;

@RunWith(SpringJUnit4ClassRunner.class)
// 指定创建容器时使用的配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class TestDemo2 {
    
    // 将名为user的对象注入到变量u变量中
    @Resource(name="user")
    private User u;
    
    @Test
    public void fun() {
        System.out.println("sss");
    }
}

AOP面向切面编程

AOP概述

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用

底层实现

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

JDK 的动态代理：类必须实现接口，所以是针对实现了接口的类产生代理.
Cglib 的动态代理：针对没有实现接口的类产生代理，应用的是底层的字节码增强的技术生成当前类的子类对象

JDK 的动态代理

UserService接口
实现增删改查的功能

package com.cuzz.service;

public interface UserService {
    void add();
    void delete();
    void update();
    void get();
}

UserService接口的实现的类

public class UserServiceImpl implements UserService {

    @Override
    public void add() {
        System.out.println("添加一个user");
    }

    @Override
    public void delete() {
        System.out.println("删除一个user");
    }

    @Override
    public void update() {
        System.out.println("更新一个user");
    }

    @Override
    public void get() {
        System.out.println("查询一个user");
    }
}

实现动态代理

package com.cuzz.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UserServiceProxyFactory implements InvocationHandler{
    
    private UserService us;

    public UserServiceProxyFactory(UserService us) {
        super();
        this.us = us;
    }
    
    // 获得动态代理
    public UserService getUserServiceProxy() {
        // 生成动态代理
        UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
                UserServiceImpl.class.getInterfaces(), 
                this);
        return usProxy;
    }
    
    @Override
    public Object invoke(Object arg0, Method method, Object[] arg2)
            throws Throwable {
        System.out.println("打开事务!");
        Object invoke = method.invoke(us, arg2);
        System.out.println("提交事务!");
        return invoke;
    }
}

测试

package com.cuzz.service;

import org.junit.Test;

public class TestDemo {
    
    @Test
    //动态代理
    public void fun1(){
        UserService us = new UserServiceImpl();
        
        UserServiceProxyFactory factory = new UserServiceProxyFactory(us);
        
        UserService usProxy = factory.getUserServiceProxy();
        
        usProxy.add();   // 打开事务!
                         // 添加一个user
                         // 提交事务!
    }
}

Cglib 的动态代理

Cglib 的动态代理的代码实现

package com.cuzz.service;

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class UserServiceProxyFactory2 implements MethodInterceptor {
    
    public UserService getUserServiceProxy(){
        // 帮我们生成代理对象
        Enhancer en = new Enhancer();
        // 设置对谁进行代理
        en.setSuperclass(UserServiceImpl.class);
        // 代理要做什么
        en.setCallback(this);
        // 创建代理对象
        UserService us = (UserService) en.create();
        return us;
    }

    @Override
    public Object intercept(Object prxoyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {
        // 打开事务
        System.out.println("打开事务!");
        // 调用原有方法
        Object returnValue = methodProxy.invokeSuper(prxoyobj, arg);
        // 提交事务
        System.out.println("提交事务!");
        
        return returnValue;
    }
}

测试

    @Test
    public void fun2(){
        
        UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();
        
        UserService usProxy = factory.getUserServiceProxy();
        
        usProxy.add();
    }

Spring的AOP开发(基于AspectJ)

AOP的开发中的相关术语

Joinpoint(连接点)：所谓连接点是指那些被拦截到的点，在 spring 中这些点指的是方法，因为 spring 只支持方法类型的连接点
Pointcut(切入点)：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
Advice(通知/增强)：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction(引介)：引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field
Target(目标对象)：代理的目标对象
Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程，spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装在期织入
Proxy（代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
Aspect(切面)：是切入点和通知（引介）的结合

导入包

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

引入AOP约束

image.png

目标类的配置

<bean name="userService" class="com.cuzz.service.UserServiceImpl" />

测试

由于我的spring-test.jar版本有点冲突，所以用不了Junit单元测试，就用原始的测试

package com.cuzz.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cuzz.pojo.User;
import com.cuzz.service.UserService;

public class TestDemo3 {
    @Test
    public void fun1() {
        // 创建spring工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过工厂解析xml获取Bean的实例
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.add();
        userService.delete();
        userService.update();
        userService.get();
    }
}

通知类型

前置通知：在目标方法执行之前执行
后置通知：在目标方法执行之后执行
环绕通知：在目标方法执行前和执行后执行
异常抛出通知：在目标方法执行出现异常的时候执行
最终通知：无论目标方法是否出现异常最终通知都会执行

切面类

package com.cuzz.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAdvice {
    
    // 前置通知
    public void before(){
        System.out.println("这是前置通知!!");
    }

    // 后置通知
    public void afterReturning(){
        System.out.println("这是后置通知(如果出现异常不会调用)!!");
    }
    // 环绕通知
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分!!");
        // 调用目标方法
        Object proceed = pjp.proceed();
        System.out.println("这是环绕通知之后的部分!!");
        return proceed;
    }
    // 异常通知
    public void afterException(){
        System.out.println("出事啦!出现异常了!!");
    }
    // 后置通知
    public void after(){
        System.out.println("这是后置通知(出现异常也会调用)!!");
    }
}

配置

    <!-- 配置目标对象 --> 
    <bean name="userService" class="com.cuzz.service.UserServiceImpl" />

    <!-- 配置通知对象 -->
    <bean name="myAdvice" class="com.cuzz.aop.MyAdvice"/>

    <!-- 配置将通知织入目标对象中 -->
    <aop:config>
        <!-- 
            配置切入点
            public void com.cuzz.service.UserServiceImpl.save()
            * com.cuzz.service.UserServiceImpl.save()
            * com.cuzz.service.UserServiceImpl.*()
            * com.cuzz.service.*ServiceImpl.*(..)
            * com.cuzz.service..*ServiceImpl.*(..)
         -->
         
        <aop:pointcut expression="execution(* com.cuzz.service..*ServiceImpl.*(..))" id="pc"/>
        <aop:aspect ref="myAdvice">
            <!-- 指定名为before方法作为前置通知 -->
            <aop:before method="before" pointcut-ref="pc" />
            <!-- 后置 -->
            <aop:after-returning method="afterReturning" pointcut-ref="pc" />
            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="pc" />
            <!-- 异常拦截通知 -->
            <aop:after-throwing method="afterException" pointcut-ref="pc"/>
            <!-- 后置 -->
            <aop:after method="after" pointcut-ref="pc"/>       
        </aop:aspect>
    </aop:config>

AOP的注解配置

导包

与前面一样

引入约束

与前面一样

配置

    <!-- 配置目标对象 --> 
    <bean name="userService" class="com.cuzz.service.UserServiceImpl" />
    <!-- 配置通知对象 -->
    <bean name="myAdvice" class="com.cuzz.aop.MyAdvice"/>
    <!-- 开启使用注解完成织入 -->
    <aop:aspectj-autoproxy />

编写注解类

package com.cuzz.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
// 表示该类是一个通知类
public class MyAdvice {
    
    // 前置通知
    @Before("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void before(){
        System.out.println("这是前置通知!!");
    }

    // 后置通知
    @AfterReturning("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void afterReturning(){
        System.out.println("这是后置通知(如果出现异常不会调用)!!");
    }
    // 环绕通知
    @Around("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分!!");
        // 调用目标方法
        Object proceed = pjp.proceed();
        System.out.println("这是环绕通知之后的部分!!");
        return proceed;
    }
    // 异常通知
    @AfterThrowing("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void afterException(){
        System.out.println("出事啦!出现异常了!!");
    }
    // 后置通知
    @After("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void after(){
        System.out.println("这是后置通知(出现异常也会调用)!!");
    }
}

最后编辑于：2018.04.12 23:56:50

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 214,588评论 6赞 496
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,456评论 3赞 389
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 160,146评论 0赞 350
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,387评论 1赞 288
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,481评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,510评论 1赞 293
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,522评论 3赞 414
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,296评论 0赞 270
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,745评论 1赞 307
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,039评论 2赞 330
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,202评论 1赞 343
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,901评论 5赞 338
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,538评论 3赞 322
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,165评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,415评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,081评论 2赞 365
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,085评论 2赞 352

Spring（二）

Spring的Bean管理（注解方式）

导入包

引入约束

快速入门

Bean管理的常用注解

类注解

Spring 属性注入的注解

Bean 的作用范围的注解

Bean的生命周期的配置

代码演示

AOP面向切面编程

AOP概述

底层实现

JDK 的动态代理

Cglib 的动态代理

Spring的AOP开发(基于AspectJ)

AOP的开发中的相关术语

导入包

引入AOP约束

目标类的配置

测试

通知类型

切面类

配置

AOP的注解配置

导包

引入约束

配置

编写注解类

推荐阅读更多精彩内容