spring IOC与AOP

Spring IOC容器

spring IOC 容器有两种，分别是 BeanFactory 容器和 ApplicationContext 容器。

BeanFactory如下：

/*第一步，利用ClassPathResource()API加载路径CLASSPATH下的可用的Bean的xml配置文件
  然后利用框架提供的 XmlBeanFactory() API生成工厂Bean，XmlBeanFactory()负责创建和初始化所有对象
  然后用getBean方法得到所需要Bean并转化类型为真正的对象
*/
XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("Beans.xml"));
HelloWorld obj = (HelloWorld) factory.getBean("helloWorld");
obj.getMessage();

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    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-3.0.xsd">

   <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">
       <property name="message" value="Hello World!"/>
   </bean>

</beans>

ApplicationContext接口的实现：

FileSystemXmlApplicationContext：从xml文件中加载已经被定义的bean，需要提供的参数为完整的XML文件路径

ClassPathXmlApplicationCOntext：从xml文件中加载已经被定义的bean，但从CLASSPATH加载xml文件

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class MainApp {
   public static void main(String[] args) {
      //第一步
      ApplicationContext context = new FileSystemXmlApplicationContext("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml");
      //第二步
　　　 HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
   }
}

Spring Bean 的作用域

singleton：是bean的默认作用域；当作用域为singleton时，IOC容器只会存在一个共享的bean实例，多次getBean时，返回的都是同一个Bean

<bean id="..." class="..." scope="singleton">
    <!-- collaborators and configuration for this bean go here -->
</bean>

prototype：表示一个bean的定义对应多个对象实例，每次getbean时都会返回一个新的bean实例；

spring的依赖注入

基于构造函数的注入

<!-- id是bean的id，用于识别bean； class是bean所对应的类-->
<bean id="textEditor" class="com.tutorialspoint.TextEditor">
      <!--constructor-arg表示基于构造函数注入 ，ref表示注入的值是引用而非一般的数值-->
      <constructor-arg ref="spellChecker"/>
</bean>

   <bean id="foo" class="x.y.Foo">
      <!-- 当构造函数存在多个参数时，按顺序定义即可按顺序传参-->
      <constructor-arg ref="bar"/>
      <constructor-arg ref="baz"/>
   </bean>

基于设值函数的依赖注入

   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
      <property name="spellChecker" ref="spellChecker"/>    <!-- property表示基于设值函数注入，设值函数的名字一定要是 setSpellChecker()-->
      <property name="name" value="John Doe"/>           <!-- name是属性的名字，value是属性的值-->
  </bean>

基于注解的配置

注解

@required：用在set方法上，一旦用了这个注解，bean在初始化时就必须对这个值进行依赖注入；否则报错

public class Zoo {
    private Dog dog ;
    public Dog getDog() {
        return dog;
    }
    @required     //如果xml文件中没有对Dog属性进行注入，则会报错
    public void setDog(Dog dog) {
        this.dog = dog;
    }
}  

@Autowired：可以不写依赖注入的配置，让容器自己寻找依赖并注入

public class Zoo {
    @Autowired        private Dog dog ;
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
}   

基于注解的注入

在xml配置中添加下列语句，告诉spring要用注解的方式进行配置

<context:annotation-config/>

import org.springframework.beans.factory.annotation.Autowired;

public class Product {     
    private int id;
    //在属性前加上Autowired注解，实现注入；
    //这时Category属性就可以不要set函数了，在xml中的Product的bean也不能再配置Category属性了；但product的bean还是需要的;
    //如果在xml中的product的bean中也配置了Category属性，则会按照xml优先的原则寻找属性对应的set函数或者构造函数，如果找不到则报错
    @Autowired
    private Category category； 

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    //也可以在设值函数前加上Autowired注解，实现注入;
   //这种情况下同上，可以不用在xml文件中配置category属性，但product的bean还是需要声明的
   @Autowired
　 public void setCategory(Category category) {
　　　 this.category = category;
　 }
}

此时的xml：仅仅去掉了对属性是引用的Category属性的配置，其它的并没有省略；（省略的是下方注释的那一行）

<?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:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <context:annotation-config/>
    <bean name="c" class="com.how2java.pojo.Category">
        <property name="name" value="category 1" />
    </bean>
    <bean name="p" class="com.how2java.pojo.Product">
        <property name="name" value="product1" />
<!--         <property name="category" ref="c" /> -->
    </bean>

</beans>

进一步省略基于注解的注入

先将xml中的什么都去掉，只新增一行<context:component-scan base-package="com.how2java.pojo"/>，这时告诉spring，bean在哪个java包下

<?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:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

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

</beans>

然后在java文件中做如下改动

package com.how2java.pojo;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

//@component表明Product类是bean，这相当于在xml中声明一个bean
@Component("p")
public class Product {
    //属性的初始化现在放在属性声明中进行
    private int id = 10;
    private String name="product 1";
    //同上，对Category属性进行自动注入
    @Autowired
    private Category category;

}

Spring AOP

aop概念

连接点（joinpoint）：一个类或者一段程序拥有的具有边界性质的特定点，叫做连接点。

切点（pointcut）：是某些特定的连接点；如果用数据库的概念来比喻连接点和切点的关系，连接点相当于客观存在的记录数据，而切点相当于查询条件；

增强（advice）：增强是织入到连接点上的一段程序代码（就是一个方法）；

目标对象：要被织入代码的类

切面：切面 = 增强 + 切点

基于xml的aop

服务类：

import org.aspectj.lang.ProceedingJoinPoint;
//增强所在的类
public class LoggerAspect {
    //增强，即要织入的方法
    public void log(JoinPoint joinPoint) throws Throwable {
        System.out.println("start log")；
        return object;
    }
}　　

xml配置：

<!-- 声明业务类对象-->
<bean name="s" class="com.how2java.service.ProductService">
</bean>
<!-- 声明服务类对象-->
<bean id="loggerAspect" class="com.how2java.aspect.LoggerAspect"/>

<aop:config>
        <!-- id是切入点的名字，定义了一个切点 -->
        <!-- expression 表示满足这个expression 的方法在被调用之后，就会执行切面操作，相当于触发了切面；-->
        <!--第一个*表示返回值返回任意类型，第二个*表示任意方法，（..）表示方法的参数是任意数量和类型 -->
        <aop:pointcut id="loggerCutpoint"  expression="execution(* com.how2java.service.ProductService.*(..)) "/>
        <!-- 定义了一个切面，切面 = 增强 + 切点-->
        <!-- id是切面的名字， ref是增强所在的类-->
        <aop:aspect id="logAspect" ref="loggerAspect">
            <!-- pointcut-ref 表示本切面和哪个切点相关联； method代表增强-->
            <!-- aop:after 表示要在何时调用增强；before在方法调用前，after在方法调用后，after-returning在方法执行成功后-->
            <!-- after-throwing在方法抛出异常后调用；around在方法调用前和调用后执行-->
            <aop:after pointcut-ref="loggerCutpoint" method="log"/>
        </aop:aspect>
</aop:config>

基于注解方式的aop

业务类如下：

package com.how2java.service;
import org.springframework.stereotype.Component;
//用component来声明这是一个bean
@Component("s")
public class ProductService {
    public void doSomeService(){
        System.out.println("doSomeService");
    }
}

服务类如下：

package com.how2java.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
//Aspect注解表示这是一个切面，component注解声明了一个bean
@Aspect
@Component
public class LoggerAspect {
    //around注解表示对目标类中的某些方法进行切面操作
    @Around(value="execution(*com.how2java.service.ProductService.*(..))")
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("start log:" + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        System.out.println("end log:" + joinPoint.getSignature().getName());
        return object;
    }
}

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:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!-- 下面两行是告诉spring应该扫描哪些包-->
    <context:component-scan base-package="com.how2java.aspect"/>
    <context:component-scan base-package="com.how2java.service"/>

    <aop:aspectj-autoproxy/> 

</beans>