JavaWeb框架————Spring（二）

1、使用注解配置Spring

代码示例

Car.java

package cn.ctgu.bean;

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

@Component("car")
public class Car {
    @Value("玛莎拉蒂")
    private String name;
    @Value("绿色")
    private String color;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    @Override
    public String toString() {
        return "Car [name=" + name + ", color=" + color + "]";
    }

}

User.java

package cn.ctgu.bean;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
//<bean name="user" class="cn.ctgu.bean.User"/>和注解等同
@Component("user")
    /*以下三个注解和上面的注解一样，只是应用于不同层注解对象时的区分，其实每个层都可以用这四个
     * @Service("user")//service层注解对象
     * @Controller("user")//web层注解对象
     * @Repository("user")//dao层注解对象
     * 
     * */
//指定对象的作用范围
@Scope(scopeName="singleton")//注解成单例或多例模式
//<bean name="user" class="cn.ctgu.bean.User" scope="singleton" init-method="init" destroy-method="destroy"></bean>
public class User {
    @Value("tom")//<property name="name" value="tom"></property>
    //通过反射的Field赋值
    private String name;

    @Value(value="18")//只有一个值的的时候，可以不写value，即@Value("18")
    private Integer age;

    @Autowired  //自动装配，为car属性注入配置的car对象，问题：如果匹配多个类型一致的对象，将无法选择具体注入哪一个对象
    /*<!--引用类型注入：为car属性注入下方配置的car对象 -->
    <property name="car" ref="car"></property>*/
    @Qualifier("car2")//使用@Qualifier注解告诉spring容器自动装配哪个名称的对象
    //@Resource(name="car2")//手动注入，指定注入哪个名称的对象，推荐使用这种
    private Car car;

    public User() {
        System.out.println("User对象空参构造方法！");
        // TODO Auto-generated constructor stub
    }
    public User(String name, Car car) {
        System.out.println("User(String name,Car car)!!");
        this.name = name;
        this.car = car;
    }

    public User(Car car, String name) {
        System.out.println("User(String name,Car car)!!");
        this.name = name;
        this.car = car;
    }
    public User(Integer name, Car car) {
        System.out.println("User(String name,Car car)!!");
        this.name = name+"";
        this.car = car;
    }

    public Car getCar() {
        return car;
    }

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

    public String getName() {
        return name;
    }
//跟上面效果一样，为name赋值   @Value("tom")//<property name="name" value="tom"></property>
    //通过set方法赋值
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @PostConstruct //在对象被创建后调用，相当于init-method
    public void init() {
        System.out.println("我是初始化方法！");
    }
    @PreDestroy  //在对象销毁之前被调用，相当于destroy-method
    public void destroy() {
        System.out.println("我是销毁方法！");
    }

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


}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd ">

<!--指定扫描cn.ctgu.bean包及子包下的所有类的注解  -->
<context:component-scan base-package="cn.ctgu.bean"></context:component-scan>   

<bean name="car2" class="cn.ctgu.bean.Car">
        <property name="name" value="兰博基尼"></property>
        <property name="color" value="黄色"></property>
    </bean> 

</beans>

2、Spring和Junit整合测试
Demo.java

package cn.ctgu.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 cn.ctgu.bean.User;

//Junit与Spring整合
@RunWith(SpringJUnit4ClassRunner.class)//帮我们创建容器
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo {
    //将名为user的对象注入到u变量中
    @Resource(name="user")
    private User u;
    @Test
    public void fun1() {
        System.out.println(u);
    }
}

配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd ">

<!--指定扫描cn.ctgu.bean包及子包下的所有类的注解  -->
<context:component-scan base-package="cn.ctgu.bean"></context:component-scan>   

<bean name="car2" class="cn.ctgu.bean.Car">
        <property name="name" value="兰博基尼"></property>
        <property name="color" value="黄色"></property>
    </bean> 

</beans>

3、Spring中的代理




代码示例

动态代理

UserService.java（接口）

package cn.ctgu.service;

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

UserServiceImpl.java（接口实现类）

package cn.ctgu.service;

public class UserServiceImpl implements UserService {

    @Override
    public void save() {
        System.out.println("保存用户");

    }

    @Override
    public void delete() {
        System.out.println("删除用户");

    }

    @Override
    public void find() {
        System.out.println("查找用户");

    }

    @Override
    public void update() {
        System.out.println("修改用户");

    }

}

UserServiceProxyFactory.java

package cn.ctgu.proxy;

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

import cn.ctgu.service.UserService;
import cn.ctgu.service.UserServiceImpl;
//动态代理
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 proxy, Method method, Object[] args) throws Throwable {

        //打开事务
        System.out.println("打开事务");
        //被增强对象的的方法
        Object invoke=method.invoke(us, args);
        //打开事务
        System.out.println("提交事务");
        return invoke;
    }

}

cglib代理
UserServiceProxyFactory2.java

package cn.ctgu.proxy;

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

import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import cn.ctgu.service.UserService;
import cn.ctgu.service.UserServiceImpl;
//cglib代理
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
    /*
     * proxyObj被代理对象（原始对象）
     * method  原始方法
     * arg  方法参数
     * methodproxy  代理方法 
     *  
     * */
    public Object intercept(Object proxyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {

        //打开事务
        System.out.println("打开事务");
        //调用原有方法
        Object returnValue=methodProxy.invokeSuper(proxyobj, arg);
        //提交事务
        System.out.println("提交事务");
        return returnValue;
    }


}

测试类
Demo.java

package cn.ctgu.proxy;

import org.junit.Test;

import cn.ctgu.service.UserService;
import cn.ctgu.service.UserServiceImpl;

public class Demo {
    //测试代理对象
    @Test
    public void fun1() {
        UserService us=new UserServiceImpl();

        UserServiceProxyFactory factory=new UserServiceProxyFactory(us);

        UserService usProxy=factory.getUserServiceProxy();

        usProxy.save();
    }
    //测试cglib代理
    @Test
    public void fun2() {

        UserServiceProxyFactory2 factory=new UserServiceProxyFactory2();

        UserService usProxy=factory.getUserServiceProxy();

        usProxy.save();
        //判断代理对象是否属于被代理对象类型
        //结果：true   因为代理对象继承被代理对象
        System.out.println(usProxy instanceof UserServiceImpl);
    }
}

4、Spring中的AOP
4.1 xml配置AOP

目标对象
UserService.java（接口）

package cn.ctgu.service;

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

UserServiceImpl.java

package cn.ctgu.service;

public class UserServiceImpl implements UserService {

    @Override
    public void save() {
        System.out.println("保存用户");

    }

    @Override
    public void delete() {
        System.out.println("删除用户");

    }

    @Override
    public void find() {
        System.out.println("查找用户");

    }

    @Override
    public void update() {
        System.out.println("修改用户");

    }

}

通知
MyAdvice.java

package cn.ctgu.aspect;

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("这是后置通知（如果出现异常也会调用）");
    }
}

配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" 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-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">
<!--准备工作：导入aop（约束）命名空间 -->
<!-- 1、配置目标对象 -->
    <bean name="userServiceTarget" class="cn.ctgu.service.UserServiceImpl"></bean>
<!-- 2、配置通知对象 -->
    <bean name="myAdvice" class="cn.ctgu.aspect.MyAdvice"></bean>
<!-- 3、配置将通知织入目标对象 -->
    <aop:config>
        <!--配置切入点
            public void cn.ctgu.service.UserServiceImpl.save()
            void cn.ctgu.service.UserServiceImpl.save() 
            * cn.ctgu.service.UserServiceImpl.save() 返回值不限制

            * cn.ctgu.service.UserServiceImpl.*()  配置所有方法，参数为空参
            * cn.ctgu.service.UserServiceImpl.*(..) 配置所有方法，参数无限制
            * cn.ctgu.service.*ServiceImpl.*(..)  配置cn.ctgu.service包下包含ServiceImpl类下的所有方法
            * cn.ctgu.service..*ServiceImpl.*(..)  配置cn.ctgu.service包及子包下包含ServiceImpl类下的所有方法
         -->
        <aop:pointcut expression="execution(* cn.ctgu.service.UserServiceImpl.*(..))" 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>
</beans>

测试类
Demo.java

package cn.ctgu.springaop;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.ctgu.bean.User;
import cn.ctgu.service.UserService;

//Junit与Spring整合
@RunWith(SpringJUnit4ClassRunner.class)//帮我们创建容器
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:cn/ctgu/springaop/applicationContext.xml")
public class Demo {
    //将名为user的对象注入到u变量中
    @Resource(name="userServiceTarget")
    private UserService us;
    @Test
    public void fun1() {
        us.save();
    }
}

4.2 使用注解配置AOP

目标对象
UserService.java

package cn.ctgu.service;

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

UserServiceImpl.java

package cn.ctgu.service;

public class UserServiceImpl implements UserService {

    @Override
    public void save() {
        System.out.println("保存用户");

    }

    @Override
    public void delete() {
        System.out.println("删除用户");

    }

    @Override
    public void find() {
        System.out.println("查找用户");

    }

    @Override
    public void update() {
        System.out.println("修改用户");

    }

}

配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" 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-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">
<!--准备工作：导入aop（约束）命名空间 -->
<!-- 1、配置目标对象 -->
    <bean name="userServiceTarget" class="cn.ctgu.service.UserServiceImpl"></bean>
<!-- 2、配置通知对象 -->
    <bean name="myAdvice" class="cn.ctgu.annotationaop.MyAdvice"></bean>
<!-- 3、开启使用注解完成织入 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

将通知织入目标对象
MyAdvice.java

package cn.ctgu.annotationaop;

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

//使用注解完成aop配置
//通知类
@Aspect//表示该类是一个通知类
public class MyAdvice {
    //前置通知（目标方法运行前调用）

    //后置通知（如果出现异常将不会调用，在目标方法运行之后调用）

    //环绕通知（在目标方法之前和之后都调用）

    //异常拦截通知（如果出现异常就会调用）

    //后置通知（无论是否出现异常都会调用，在目标方法运行之后调用）
//===================================================
    //抽取出注解，以便后面使用MyAdvice.pc,否则将要写全
    @Pointcut("execution(* cn.ctgu.service.UserServiceImpl.*(..))")
    public void pc() {}

    //前置通知
    //指定该方法是前置通知，并制定切入点
    //@Before("execution(* cn.ctgu.service.UserServiceImpl.*(..))")
    @Before("MyAdvice.pc()")
    public void before() {
        System.out.println("这是前置通知！！");
    }
    //后置通知
    //@AfterReturning("execution(* cn.ctgu.service.UserServiceImpl.*(..))")
    @AfterReturning("MyAdvice.pc()")
    public void afterReturning() {
        System.out.println("这是后置通知（如果出现异常将不会调用）");
    }
    //环绕通知
    //@Around("execution(* cn.ctgu.service.UserServiceImpl.*(..))")
    @Around("MyAdvice.pc()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分");
        Object proceed=pjp.proceed();//调用目标方法
        System.out.println("这是环绕通知之后的部分");
        return proceed;
    }
    //异常拦截通知
    //@AfterReturning("execution(* cn.ctgu.service.UserServiceImpl.*(..))")
    @AfterReturning("MyAdvice.pc()")
    public void afterException() {
        System.out.println("出事了！出现异常了");
    }
    //后置通知
    //@After("execution(* cn.ctgu.service.UserServiceImpl.*(..))")
    @After("MyAdvice.pc()")
    public void after() {
        System.out.println("这是后置通知（如果出现异常也会调用）");
    }
}

测试类
Demo.java

package cn.ctgu.annotationaop;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.ctgu.bean.User;
import cn.ctgu.service.UserService;

//Junit与Spring整合
@RunWith(SpringJUnit4ClassRunner.class)//帮我们创建容器
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:cn/ctgu/annotationaop/applicationContext.xml")
public class Demo {
    //将名为user的对象注入到u变量中
    @Resource(name="userServiceTarget")
    private UserService us;
    @Test
    public void fun1() {
        us.save();
    }
}