Spring第二次案例和AOP

Spring加上AOP

com.mapper.entity.UserInfo

package com.Spring.entity;

public class UserInfo {
    private Integer user_id;
    private String  user_name;

    public Integer getUser_id() {
        return user_id;
    }

    public void setUser_id(Integer user_id) {
        this.user_id = user_id;
    }

    public String getUser_name() {
        return user_name;
    }

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }
}

package com.Spring.mapper.IUserInfoMapper

/*
* Dao层接口
* */
public interface IUserInfoMapper {
    //添加用户
    public int addUser(UserInfo info);
}

package com.Spring.mapper.impl.IUserInfoMapperImpl

    @Override
    public int addUser(UserInfo info) {
        System.out.println("add success!");
        return 0;
    }
}

package com.Spring.service.IUserInfoService

public interface IUserInfoService {
    //添加用户
    public int addUser(UserInfo info);
}

package com.Spring.service.impl.IUserInfoServiceImpl

public class IUserInfoServiceImpl implements IUserInfoService {
    //注入Dao层对象
    private IUserInfoMapper iUserInfoMapper;

    public IUserInfoMapper getiUserInfoMapper() {
        return iUserInfoMapper;
    }

    public void setiUserInfoMapper(IUserInfoMapper iUserInfoMapper) {
        this.iUserInfoMapper = iUserInfoMapper;
    }

    @Override
    public int addUser(UserInfo info) {
        int count = iUserInfoMapper.addUser(info);
        return count;
    }
}

applicationContext.xml

<!--声明Daobean      bean的注入注入的都是实现类-->
    <bean id="iUserInfoMapper" class="cn.spring.mapper.impl.IUserInfoMapperImpl"></bean>
        <!--声明Service-->
    <bean id="iUserInfoService" class="cn.spring.service.impl.IUserInfoServiceImpl">
        <!--setter方法怎么注入：找到Name属性值，将属性值的开头改为大写，然后前缀加上setIUserInfoMapper-->
        <property name="iUserInfoMapper" ref="iUserInfoMapper"></property>
    </bean>

AOP(面向切面编程)

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

AOP相关概念

Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：织入 Advice 的目标对象.。
Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

AOP

依赖

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

package com.Spring.advice.MyAdvice

public class MyAdvice implements MethodBeforeAdvice, AfterReturningAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("============前置增强：日志处理等操作========================");
    }

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("============后置增强：事务处理等操作=========================");
    }
}

applicationContext.xml

<?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"
xmlns:p="http://www.springframework.org/schema/p"

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="myBeforeAdvice" class="cn.spring.advice.MyAdvice"></bean>
<!--增强处理:-->
<aop:config>
&lt;!&ndash;切点:你要对哪一个方法进行增强 expression:切点表达式匹配的
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
modifiers-pattern：方法的可见性，如public，protected；
ret-type-pattern：方法的返回值类型，如int，void等；
declaring-type-pattern：方法所在类的全路径名，如com.spring.Aspect；
name-pattern：方法名类型，如buisinessService()；
param-pattern：方法的参数类型，如java.lang.String；
throws-pattern：方法抛出的异常类型，如java.lang.Exception；
通配符：
*通配符，该通配符主要用于匹配单个单词，或者是以某个词为前缀或后缀的单词。
..通配符，该通配符表示0个或多个项
public int addUser(UserInfo)

* *..service.*.*(..)
&ndash;&gt;
<aop:pointcut id="pointcut" expression="execution(* *..service.*.*(..))"/>
&lt;!&ndash;织入：将增强处理和切点表达式符合的方法关联到一起&ndash;&gt;
<aop:advisor advice-ref="myBeforeAdvice" pointcut-ref="pointcut"></aop:advisor>

</aop:config>

package com.Spring.advice.MyAdvice2

/**
 * 增强类
 */
public class MyAdvice2 {
    //前置增强
    public void before(){
        System.out.println("=========基于配置的前置增强================");
    }
    
    //后置增强
    public  void after(){
        System.out.println("=========基于配置的后置增强================");
    }
    
}

applicationContext.xml

    <!--配置增强-->
    <aop:config>
        <!--切点-->
        <aop:pointcut id="pointcut" expression="execution(* *..service.*.*(..))"/>
        <!--织入 ref指向增强类的bean-->
        <aop:aspect ref="myadvice">
            <!--method增强方法-->
            <aop:before method="before" pointcut-ref="pointcut"></aop:before>
            <aop:after method="after" pointcut-ref="pointcut"></aop:after>
        </aop:aspect>
    </aop:config>

    <!--基于Setter注入-->
    <bean id="student" class="cn.spring.di.Student">
        <property name="stu_id" value="1"></property>
        <property name="stu_name" value="张三"></property>
    </bean>

    <!--基于构造注入-->
    <bean id="student" class="cn.spring.di.Student">
        <!--构造注入：  name代表构造内参数的名字  value代表参数值     type代表参数数据类型     index参数下标-->
        <constructor-arg  value="2" type="java.lang.Integer" index="0"></constructor-arg>
        <constructor-arg  value="李四" type="java.lang.String" index="1"></constructor-arg>
    </bean>

    <!--P命名空间注入:基于setter注入，代表参数必须有set方法-->
   <bean id="student" class="cn.spring.di.Student" p:stu_name="王五" p:stu_id="3">

    </bean>