类扫描注解

案例

1、创建实例（Persion和Student）

@Component("persion")//相当于<bean id = "persion" class = "../Persion"></bean>
public class Persion {
    @Resource(name = "student")
    private Student student;
    public void say(){
        student.say();
    }
}


@Component("student")
public class Student {
    public void say(){
        System.out.println("student");
    }
}

2、配置文件进行配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
      <context:component-scan base-package="spring.com.bxp.bean"></context:component-scan>
</beans>

3、测试

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Persion persion = (Persion) context.getBean("persion");
        persion.say();
    }  

步骤：

1、启动Spring容器
2、Spring容器解析到类扫描注解解析器<context:component-scan base-package="spring.com.bxp.bean"></context:component-scan>的时候，在base-package指定的包及其子包下查找所有的类
3、查看哪些类上面含有@Component
4、如果注解的value属性的值为空，则把类名的第一个字母变为小写，作为id值，放入到Spring容器中
5、如果value属性的值不为空，则使用value的值作为id值，放入到spring容器中。
6、在查找spring中的类的所有属性，按照@Resource的规则进行查找。
综上所述，使用了类扫描机制的做法，配置文件中配置很简单，但是效率越来越低。

继承

案例1

1、创建实例（Book， Persion， Student）

public class Book {
    public void read(){
        System.out.println("阅读书籍");
    }
}


public class Persion {
    private Book book;
    
    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }

    public void read(){
        book.read();
    }
}


public class Student extends Persion{
    
}

2、配置文件

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


        <bean id="persion" class="spring.com.bxp.bean.Persion">
            <property name="bok" ref="book"></property>
        </bean>
        <bean id="student" class="spring.com.bxp.bean.Student"></bean>
        <bean id="book" class="spring.com.bxp.bean.Book"></bean>
</beans>

3、测试

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        student.read();
    }  

运行结果出错，空指针，说明在student中没有继承persion中book属性的值。
解决办法，在配置文件的student的bean上添加属性parent

<bean id="student" class="spring.com.bxp.bean.Student" parent="persion"></bean>

案例二

1、创建实例

@Component
public class Book {
    public void read(){
        System.out.println("阅读书籍");
    }
}

@Component
public class Persion {
    @Resource(name = "book")
    private Book book;

    public void read(){
        book.read();
    }
}


@Component
public class Student extends Persion{
    
}

2、配置文件

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

    <context:component-scan base-package="spring.com.bxp.bean"></context:component-scan>
</beans>

3、测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        student.read();
    }  
}

运行结果正确

综上连个案例：在使用继承的过程中，在配置文件中给属性赋值，需要使用parent属性。使用注解给属性赋值，则不需要。

AOP

切入点表达式

切入点表达式对应图

execution(public * *(..))：所有的公共方法
execution(* set*(..)) ：代表所有的以set开头的方法
execution(* com.xyz.server.AccountServer.*(..))：代表com.xyz.server包下的AccountServer类中的所有方法
execution( * com.xyz.server.*.*(..))：代表con.xyz.server包下的所有类中的所有方法
execution( * com.xyz.server..*.*(..))：代表con.xyz.server包及其子包下的所有类中的所有方法

第一个AOP程序

引入两个jar包

aspectjrt.jar
aspectjweaver.jar

1、创建对象

public interface Dao {
    void save();
    void update();
}


public  class DaoImpl implements Dao{
    @Override
    public void save() {
        System.out.println("保存数据");
        /**
         * 此处书写保存全部数据数据的程序
         */
    }

    @Override
    public void update() {
        /**
         * 此处书写更新数据的程序
         */
    }

}


public class Transaction {
    public void open(){
        System.out.println("开启事物");
    }
    public void commit(){
        System.out.println("提交事物");
    }
}

2、创建配置文件
引入以下名称空间：

xmlns:aop="http://www.springframework.org/schema/aop"

http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
           
    <bean id="daoimpl" class="spring.com.bxp.proxy.DaoImpl"></bean>
    <bean id="transaction" class="spring.com.bxp.proxy.Transaction"></bean>
    
    
    <aop:config>
    <!-- 切入点 -->
        <aop:pointcut expression="execution(* spring.com.bxp.proxy.DaoImpl.*(..))"
         id="perform"/>
         <!-- 切面 -->
        <aop:aspect ref="transaction" >
            <!-- aop:before：前置通知 
            aop:after-returning：后置通知
            pointcut-ref：指向切入点表达式
            -->
            <aop:before pointcut-ref="perform" method="open"/>
            <aop:after-returning pointcut-ref="perform" method="commit"/>
        </aop:aspect>
    </aop:config>


</beans>

3、测试类

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        Dao dao = (Dao) context.getBean("daoimpl");
        dao.save();
    }

AOP步骤：

1、启动spring容器
2、实例化bean对象
3、spring容器 解析aop配置
（1）切入点表达式：把id对应的类包含进spring容器
（2）前置通知，后置通知
4、spring容器会按照切入点表达式所匹配的类在spring容器中进行查找，如果找到该类，则会创建代理对象，如果找不到，则报错。
5、spring容器产生代理对象的方法：通知+目标方法
6、客户端通过context.getBean()得到一个对象，如果该对象有代理，则返回代理对象，如果没有代理，则返回对象本身。

说明：1、客户端通过context.getBean()得到一个对象，如果该对象有代理，则返回代理对象，如果没有代理，则返回对象本身
2、如果目标类实现了接口，则采用jvm生成代理对象，如果没有实现接口，则采用cglib生成代理对象，而生成代理对象时候spring来做。

spring的通知：

前置通知：具有JoinPoint参数

    /**
     * 连接点，代表一个方法，客户端调用那个方法，那个方法就是连接点
     * 
     * 通过参数可以获取连接点的一些信息
     * @param joinPoint
     */
    public void open(JoinPoint joinPoint){
        //获取目标类
        joinPoint.getTarget();
        //获取连接点参数
        joinPoint.getArgs();
        //获取连接点的名称
        joinPoint.getSignature().getName();
        System.out.println("开启事物");
    }

    <!-- aop:before：前置通知 
    pointcut-ref：指向切入点表达式
    -->
    <aop:before pointcut-ref="perform" method="open"/>

后置通知：

    /**
     * @param joinPoint:连接点
     * @param val：接受目标参数的返回值
     */
    public void commit(JoinPoint joinPoint, Object val){
        System.out.println("提交事物");
    }

    <!-- 
    aop:after-returning：后置通知
    val:和后置通知方法的参数名称保持一致
    -->
    <aop:after-returning pointcut-ref="perform" method="commit" returning="val"/>
        
如果目标方法遇到异常，后置通知将不执行

最终通知：

    /**
     * 
     * @param joinPoint:连接点
     */
    public void finallyMythod(JoinPoint joinPoint){
        
    }

    <aop:after method="finallyMythod" pointcut-ref="perform"/>
不管目标方法是否遇到异常，最终通知都会执行

异常通知：

    /**
     * 
     * @param joinPoint
     * @param throwable:获取目标方法抛出的异常
     */
    public void thowingMythod(JoinPoint joinPoint, Throwable throwable){
        
    }

    <!-- 
    throwing：和通知中的异常参数名称相同
     -->
    <aop:after-throwing method="thowingMythod" pointcut-ref="perform" throwing="throwable"/>

环绕通知：

    public void arroundMythod(ProceedingJoinPoint joinPoint) throws Throwable{
        joinPoint.proceed();//执行目标方法
    }

    applicationContext.xml
环绕通知可以控制目标方法的执行