Spring aop注入

一.AOP（Aspect Oriented Programing）面向切面编程

AOP的终极目标：让我们可以专心做事

下面通过一个例子来介绍AOP的具体使用

案例的要求：使用AOP实现日志记录系统 ，  核心模块  和    增强  单独  开发  ，运行时再组装

首先定义接口和方法

接口和实现类中的代码，我放在一起了，应该比较简单

package demo04.dao;

/**
 * Created by mycom on 2018/3/5.
 */
public interface IHelloDao {
    public void doSome();
}

package demo04.dao;

/**
 * Created by mycom on 2018/3/5.
 */
public class HelloDaoImpl implements IHelloDao {
    public void doSome() {
        System.out.println("已经成功加入到DB中了");
    }
}

package demo04.service;

/**
 * Created by mycom on 2018/3/5.
 */
public interface IHelloService {
    public void doSome();
}

package demo04.service;

import demo04.dao.IHelloDao;

/**
 * Created by mycom on 2018/3/5.
 */
public class HelloServiceImpl implements IHelloService {
    //创建一个Dao的对象
    IHelloDao dao;

    public IHelloDao getDao() {
        return dao;
    }

    public void setDao(IHelloDao dao) {
        this.dao = dao;
    }

    public void doSome() {
        dao.doSome();
    }
}

同样在resources下面也要有一个xml文件----applicationContext.xml

<!--返回的类型只能是实现类-->  这里需要注意一下  class的值只能是实现类的包
    <bean id="dao" class="demo04.dao.HelloDaoImpl">
    </bean>

    <bean id="service" class="demo04.service.HelloServiceImpl">
        <property name="dao" ref="dao"></property>
    </bean>

然后编写测试类进行测试

@Test
    public void t1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContextAop.xml");
        //这里的返回值只能是接口
        IHelloService service =(IHelloService) context.getBean("service");
        service.doSome();
    }

运行的结果

现在我们要在这句话出现之前，先记录一下日志，出现之后，再出现一句话

首先要创建一个新的包AOP包，并且在包下面写两个类

LoggerAfter是后置增强

LoggerBefore是前置增强

这两个类中的代码如下

package demo04.aop;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

/**
 * Created by mycom on 2018/3/5.
 */
public class LoggerAfter implements AfterReturningAdvice {
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("=======after");
    }
}

package demo04.aop;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * Created by mycom on 2018/3/5.
 */
public class LoggerBefore implements MethodBeforeAdvice {
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("日志记录");
    }
}

在xml中配置，在配置xml是要给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/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">

<bean id="service" class="demo04.service.HelloServiceImpl">
        <property name="dao" ref="dao"></property>
    </bean>
    <!--前置-->
    <bean id="beforeAdvice" class="demo04.aop.LoggerBefore">
    </bean>
    <!--后置-->
    <bean id="afterAdvice" class="demo04.aop.LoggerAfter">
    </bean>
    <!--配置aop-->
    <aop:config>
        <!--切点-->
        <aop:pointcut id="mypoint" expression="execution(public void demo04.service.HelloServiceImpl.doSome())"></aop:pointcut>
        <!--<aop:pointcut id="mypoint" expression="execution(* *..service.*.*(..))"></aop:pointcut>-->
        <!--advice-ref:做什么样的配置，是前置还是后置
        pointcut-ref：锁定什么样的方法规则，那个方法需要被锁定
        -->
        <aop:advisor advice-ref="beforeAdvice" pointcut-ref="mypoint"></aop:advisor>
        <aop:advisor advice-ref="afterAdvice" pointcut-ref="mypoint"></aop:advisor>
    </aop:config>

测试类

import demo04.service.HelloServiceImpl;
import demo04.service.IHelloService;
import demo05.MyCollection;
import demo05.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by mycom on 2018/3/3.
 */
public class Test20180305 {
    @Test
    public void t1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContextAop.xml");
        //这里的返回值只能是接口
        IHelloService service =(IHelloService) context.getBean("service");
        service.doSome()；

    }


}

在这里和要介绍两个单词的意思

advice ：通知
advisor：顾问

顾问可以包装通知
execution(【modifiers-pattern?】 访问修饰符
ret-type-pattern 返回值类型
【declaring-type-pattern?】 全限定性类名
name-pattern(param-pattern) 方法名(参数名) 包名.类型名.方法名
【throws-pattern?】) 抛出异常类型
public void doLog(String log){

}
方法签名
切入点表达式要匹配的对象就是目标方法的方法名。所以，execution表达式中明显就是方法的签名。
注意：表达式中加[]的部分表示可省略部分，各部分间用空格分开。在其中可以使用以下符号：
符号 意义
* 0至多个任意字符
.. 用在方法参数中，表示任意多个参数
用在包名后，表示当前包及其子包路径
+ 用在类名后，表示当前类及其子类
用在接口后，表示当前接口及其实现类
案例：
execution(public * *(..)) 指定切入点为：任意公共方法
execution(* set*(..)) 指定切入点为：任何一个以"set"开始的方法

二.给属性注入值（四种）

1.setter方法注入（就是在bean节点下有property节点给里面的属性值赋值

<bean id="service" class="demo04.service.HelloServiceImpl">
        <property name="dao" ref="dao"></property>
    </bean>

2.构造注入

3.p命名空间注入（使用前要先要在Spring配置文件中引入p命名空间xmlns:p="http://www.springframework.org/schema/p"）

这里的两种我写在一起了

首先写一个学生类，车类，MyCollection

package demo05;

/**
 * Created by mycom on 2018/3/5.
 */
public class Student {
    private String name;
    private Integer age;
    private Car car;

    public Student() {
    }

    public Student(String name, Integer age) {

        this.name = name;
        this.age = age;
    }

    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;
    }
}

package demo05;

/**
 * Created by mycom on 2018/3/5.
 */
public class Car {
    private String color;
    private String brand;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {

        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

在xml中的配置

<!--构造注入-->
    <!--<bean id="stu" class="demo05.Student">
        <constructor-arg index="0" value="小明"></constructor-arg>
        <constructor-arg index="1" value="12"></constructor-arg>
    </bean>-->
    <!--p命名空间注入-->
    <bean id="stu" class="demo05.Student" p:name="小明" p:age="12" p:car-ref="car"></bean>

最后编写测试类

以p命名空间注入为例进行测试

import demo04.service.HelloServiceImpl;
import demo04.service.IHelloService;
import demo05.MyCollection;
import demo05.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by mycom on 2018/3/3.
 */
public class Test20180305 {
    @Test
    public void t1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContextCon.xml");

Student service2 =(Student) context.getBean("stu");
System.out.println(service2.getName());

 } }

4.集合注入

再写一个MyCollection类

package demo05;


import java.util.*;

/**
 * Created by mycom on 2018/3/5.
 */
public class MyCollection {
    private String[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    public MyCollection() {
        System.out.println("创建对象===========");
    }

    public MyCollection(String[] array, List<String> list, Set<String> set, Map<String, String> map, Properties properties) {
        this.array = array;
        this.list = list;
        this.set = set;
        this.map = map;
        this.properties = properties;
    }

   @Override
    public String toString() {
        return "MyCollection{" +
                "array=" + Arrays.toString(array) +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", properties=" + properties +
                '}';
    }

    public String[] getArray() {
        return array;
    }

    public void setArray(String[] array) {
        this.array = array;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Set<String> getSet() {
        return set;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
}

<!--集合注入-->
    <bean id="collection" class="demo05.MyCollection" scope="prototype">
        <!--Array-->
        <property name="array">
            <array>
                <value>小明</value>
                <value>小兰</value>
            </array>
        </property>
        <!--list-->
        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
            </list>
        </property>
        <!--set-->
        <property name="set">
            <set>
                <value>set1</value>
                <value>set2</value>
            </set>
        </property>
        <!--map-->
        <property name="map">
            <map>
                <entry key="1">
                    <value>01</value>
                </entry>
                <entry key="2">
                    <value>02</value>
                </entry>
            </map>
        </property>
        <!--propreties-->
        <property name="properties">
            <props>
                <prop key="001">001</prop>
                <prop key="002">002</prop>
            </props>
        </property>
    </bean>

import demo04.service.HelloServiceImpl;
import demo04.service.IHelloService;
import demo05.MyCollection;
import demo05.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by mycom on 2018/3/3.
 */
public class Test20180305 {
    @Test
    public void t1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContextCon.xml");
       //返回的类型只能是接口
        MyCollection service =(MyCollection) context.getBean("collection");
        System.out.println(service);
       }


}

三.Spring中bean是单例的问题

单例：一个类在内存中只能有一个对象。

单利满足的三个条件：

1.构造私有

2.是有的静态变量，变量的类型就是当前类的类型

3.提供一个静态方法

在xml中配置实现单例还是多例的属性是scope

他的值有两个singleton  单例

　　　　　　prototype 多例

在上面的集合注入的例子中进行改动，并且如果MyCollection中有toString方法，也要注释掉，可以更直观的看到，如下

然后我们来编写测试方法进行测试

import demo04.service.HelloServiceImpl;
import demo04.service.IHelloService;
import demo05.MyCollection;
import demo05.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by mycom on 2018/3/3.
 */
public class Test20180305 {
    @Test
    public void t1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContextCon.xml");
       
        MyCollection service =(MyCollection) context.getBean("collection");
        System.out.println(service);
        MyCollection service2 =(MyCollection) context.getBean("collection");
        System.out.println(service2);

    }


}

运行结果

从运行结果来看，两次创建的对象的指针不同，创建的是两个对象，这是多例

线面再来看单例，将scope的属性值改为singleton

此时的运行结果如下

他只创建了依次对象，实现了单利