Spring 实战4学习笔记（转）

http://blog.csdn.net/21aspnet/article/details/51386557

1.IOC装配Bean

参考【spring实战4 2.2】，作者提倡无XML配置化。

1.1接口只有一个现实类

可以自动装配

package demo;

public interface CompactDisc {
    void play(); 
}

实现类

package demo;

import org.springframework.stereotype.Component;

@Component 
 6 public class SgtPeppers implements CompactDisc{
    private String title = "Sgt. Pepper's Lonely Hearts Club Band";  
    private String artist = "http://blog.csdn.net/unix21";  
      
    public void play() {  
        System.out.println("【非常醒目SgtPeppers 】>>>>>>>>>>>>>>>>>Playing " + title + " by " + artist);  
    }  
}

 配置类

package demo;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration  
@ComponentScan  
public class CDPlayerConfig {

}

单元测试类

package demo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes = CDPlayerConfig.class)  
public class CDPlayerTest {  
    @Autowired  
    @Qualifier("spn")
    private CompactDisc cd;  
   
    @Test  
    public void play() {  
        cd.play();  
    }  
} 

测试结果

1.2 接口有多个实现类

【参考 Spring实战4 3.3】
故意再写一个实现类

package demo;

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;


@Component 
public class SgtPeppersNew implements CompactDisc{
    private String title = "Sgt. Pepper's Lonely Hearts Club Band";  
    private String artist = "http://blog.csdn.net/unix21";  
      
    public void play() {  
        System.out.println("【非常醒目SgtPeppersNew 】>>>>>>>>>>>>>>>>>Playing " + title + " by " + artist);  
    }  
}

此时有两个实现类，如果这时执行单元测试类的时候，测试类不知道注入（DI）那个实现类，所以会报错。

两种解决方案：1，加@Primary 首选标识的bean  2， 使用@Qualifier注解@Qualifier("SgtPeppersNew")， 改变@Component("SgtPeppersNew") 　 或者@Qualifier 注解中用实现类，但id是小写@Qualifier("sgtPeppersNew")，不需要改变@Component

package demo;

import org.springframework.stereotype.Component;


@Component
public class SgtPeppersNew implements CompactDisc{
    private String title = "Sgt. Pepper's Lonely Hearts Club Band";  
    private String artist = "http://blog.csdn.net/unix21";  
      
    public void play() {  
        System.out.println("【非常醒目SgtPeppersNew 】>>>>>>>>>>>>>>>>>Playing " + title + " by " + artist);  
    }  
}

package demo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes = CDPlayerConfig.class)  
public class CDPlayerTest {  
    @Autowired  
    @Qualifier("sgtPeppersNew")
    private CompactDisc cd;  
   
    @Test  
    public void play() {  
        cd.play();  
    }  
} 

打印结果

1.3 为组件扫描的bean命名　　

【参考 Spring实战4  2.2.2】

import org.springframework.stereotype.Component;  
  
@Component("spn")  
public class SgtPeppersNew implements CompactDisc { 

    @Autowired  
    @Qualifier("spn")   
    private CompactDisc cd;  

也可以使用@Named效果是一样的，这是java依赖注入规范

import javax.inject.Named;  
  
@Named("spn")  
public class SgtPeppersNew implements CompactDisc {  

1.4 设定组件扫描的指定包

【参考 Spring实战4  2.2.3】

如果@ComponentScan默认不设置只扫描配置类所在的包作为基础包

@Configuration  
@ComponentScan("blog.csdn.net.unix21")  
public class CDPlayerConfigTest 

设置@ComponentScan的value属性就可以指明包名称。

如果想更清晰的表明设置的是基础包
@ComponentScan(basePackages="指定包")

指定多个

@ComponentScan(basePackages={"指定包1","指定包2"})

也可以将其指定为包中所包含的类或者接口

@ComponentScan(basePackages={"XXX.class","XX.class"})

1.5 自动装配

【参考 Spring实战4  2.2.4】

声明自动装配需要@Autowired注解

1.5.1 在构造方法上使用自动装配

package demo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner；  
  
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes = CDPlayerConfigTest.class)  
public class CDPlayerFunTest {  
    private CompactDisc cd;  
    @Autowired  
    @Qualifier("spn") 
    public void CDPlayer(CompactDisc cd) {  
        this.cd = cd;  
    }  
   
    @Test  
    public void play() {  
        cd.play();  
        System.out.println("【占位符】CDPlayerFunTest");  
    }  
} 

另一种写法

@Component  
public class CDPlayer implements MediaPlayer {  
  private CompactDisc cd;  
  
  @Autowired  
  public CDPlayer(@Qualifier("spn")CompactDisc cd) {  
    this.cd = cd;  
  }  
  
  public void play() {  
    cd.play();  
  }  
  
}  

1.5.2 在属性Setter方法上使用自动装配

@Component  
public class CDPlayer implements MediaPlayer {  
  private CompactDisc cd;  
    
  @Autowired  
  @Qualifier("spn")  
  public void setCompactDisc(CompactDisc cd) {  
    this.cd = cd;  
  }  
  
  public void play() {  
    cd.play();  
  }  
}  

避免异常声明  @Autowired(required = false)，如果没有匹配的bean，Spring会让这个bean处于未装配转态，但是需要谨慎对待这个设置，代码需要做null检查。

@Autowired是Spring特有的注解，可以替换为@Inject，@Inject来源自Jave依赖注入规范。

1.6 创建自定义的限定符

【参考 Spring实战4  3.3.2】

@Component  
@Qualifier("cold")  
public class IceCream implements CompactDisc {  
  
    private String title = "Sgt. Pepper's Lonely Hearts Club Band";  
    private String artist = "The Beatles";  
  
    public void play() {  
        System.out.println("【非常醒目 IceCream】>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Playing " + title + " by " + artist);  
    }  
}  

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes=CDPlayerConfigTest.class)  
public class CDPlayerLogTest {  
  
  @Autowired  
  private MediaPlayer player;  
    
  @Autowired  
  @Qualifier("sp")  
  private CompactDisc cd;  
    
  @Autowired  
  @Qualifier("cold")  
  private CompactDisc cd2;  
    
  @Test  
  public void cdShouldNotBeNull() {  
    assertNotNull(cd);  
  }  
  
  @Test  
  public void play() {  
    player.play();  
    cd.play();  
    cd2.play();  
  }  
}  

好处：这样做的好处限定符不耦合类名，所以可以随意重构类名。

问题：重复的限定符出现在多个类上这是不允许的，因为Java不允许同一个条目上重复出现相同类型的多个注解。

注意：此时我用本地测试时发现  private MediaPlayer player;  这个player 并不能注入到测试类中，需要以后解决。

解决：注意其实CDplayer 也是需要创建的组件类，所以也要加上@Component

1.7 使用自定义限定符注解

针对上述问题可以创建自定义的限定符注解。

@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到    
@Target({ElementType.CONSTRUCTOR,ElementType.FIELD,ElementType.METHOD,ElementType.TYPE})//定义注解的作用目标**作用范围字段、枚举的常量/方法    
@Qualifier  
public @interface Cold {}  

@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到    
@Target({ElementType.CONSTRUCTOR,ElementType.FIELD,ElementType.METHOD,ElementType.TYPE})//定义注解的作用目标**作用范围字段、枚举的常量/方法    
@Qualifier  
public @interface Creamy {}  

@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到    
@Target({ElementType.CONSTRUCTOR,ElementType.FIELD,ElementType.METHOD,ElementType.TYPE})//定义注解的作用目标**作用范围字段、枚举的常量/方法    
@Qualifier  
public @interface Fruity {}  

@Component  
@Cold  
@Creamy  
public class IceCream implements CompactDisc {  
  
    private String title = "Spring 实现 第4版 读书笔记";  
    private String artist = "http://blog.csdn.net/unix21";  
  
    public void play() {  
        System.out.println("【非常醒目 IceCream】>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Playing " + title + " by " + artist);  
    }  
}  

@Component  
@Cold  
@Fruity  
public class Popsicle implements CompactDisc {  
  
    private String title = "Spring 实现 第4版 读书笔记";  
    private String artist = "http://blog.csdn.net/unix21";  
  
    public void play() {  
        System.out.println("【非常醒目 Popsicle】>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Playing " + title + " by " + artist);  
    }  
}  

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes = CDPlayerConfigTest.class)  
public class CDPlayerLogTest {  
  
    @Autowired  
    private MediaPlayer player;  
  
    @Autowired  
    @Qualifier("sp")  
    private CompactDisc cd;  
  
    @Autowired  
    @Cold  
    @Creamy  
    private CompactDisc cd2;  
  
    @Autowired  
    @Cold  
    @Fruity  
    private CompactDisc cd3;  
  
    @Test  
    public void cdShouldNotBeNull() {  
        assertNotNull(cd);  
    }  
  
    @Test  
    public void play() {  
        player.play();  
        cd.play();  
        cd2.play();  
        cd3.play();  
    }  
}  

1.8 bean的作用域

Spring定义了多重作用域，singleton单例，prototype原型等

参考：spring中scope作用域

singleton单例：整个应用中，只创建bean的一个实例，默认Spring上下文中所有的bean都是单例。

prototype原型：每次注入或者通过Spring应用上下文获取的时候，都会创建一个新的bean实例。

@Component  
public class Add implements AddI {  
    public  int a=0;  
     
    public  void Add() {  
        a++;  
    }  
      
    public  void getA() {  
        System.out.println("【非常醒目 Add】>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>a= " +a+"");  
    }  
}  

public interface AddI {  
void Add();  
    void getA();  
}  

@Component  
public class CDPlayer implements MediaPlayer {  
  
    @Autowired  
    @Qualifier("sp")  
    private CompactDisc cd;  
      
    @Autowired  
    private AddI a;  
  
    public void play() {  
        System.out.println("【非常醒目 CDPlayer】>>>");  
        cd.play();  
        a.Add();  
        a.getA();  
        a.Add();  
        a.getA();  
        System.out.println("【非常醒目 CDPlayer】<<<");  
    }  
}  

测试用例

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes = CDPlayerConfigTest.class)  
public class CDPlayerLogTest {  
  
    @Autowired  
    private MediaPlayer player;  
  
    @Autowired  
    @Qualifier("sp")  
    private CompactDisc cd;  
  
    @Autowired  
    @Cold  
    @Creamy  
    private CompactDisc cd2;  
  
    @Autowired  
    @Cold  
    @Fruity  
    private CompactDisc cd3;  
  
    @Test  
    public void cdShouldNotBeNull() {  
        assertNotNull(cd);  
    }  
  
    @Autowired  
    private AddI a;  
      
    @Test  
    public void play() {  
        player.play();  
        cd.play();  
        cd2.play();  
        cd3.play();  
        a.getA();  
    }  
}  

再写一个多线程

public class ClientThread extends Thread {  
  
    @Autowired  
    private AddI a;  
  
    @Autowired  
    public ClientThread(AddI a) {  
        this.a = a;  
    }  
  
    public void run() {  
        a.Add();  
        a.getA();  
    }  
}  

调用多线程

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes = CDPlayerConfigTest.class)  
public class SpringScopeTest {  
  
    @Autowired  
    private AddI a;  
  
    @Test  
    public void Scope() {  
        for (int i = 0; i < 10; i++) {  
            ClientThread t = new ClientThread(a);  
            t.start();  
        }  
    }  
}  

此时add实现类如下

@Component
//@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)  
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)  
public class Add implements AddI{
    public  int a=0; 
    public void Add() {
        // TODO Auto-generated method stub
        a++;  
    }

    public void getA() {
        // TODO Auto-generated method stub
        System.out.println("【非常醒目 Add】>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>a= " +a+"");  
    }

}

如果使用单例模式则

补充说明：@Repository、@Service、@Controller 和 @Component将类标识为Bean，都是一样的，用在不同的地方而已。

2.AOP切面编程

定义接口

public interface PerformanceI {  
    public void perform();  
} 

实现类

import org.springframework.stereotype.Component;  
  
@Component  
public class Performance implements PerformanceI{  
    public void perform(){  
    System.out.println("【非常醒目  Performance perform 调用中】 By http://blog.csdn.net/unix21");     
    }  
}  

定义切面

import org.aspectj.lang.annotation.After;  
import org.aspectj.lang.annotation.AfterThrowing;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.annotation.Before;  
  
@Aspect  
public class MyAspect {  
    @Before("execution(* com.demo.PerformanceI.perform(..))")  
    public void before(){  
    System.out.println("【非常醒目 [方法调用前] 】");  
    }  
      
    @After("execution(* com.demo.PerformanceI.perform(..))")  
    public void after(){  
    System.out.println("【非常醒目 [方法调用后] 】");  
    }  
      
    @AfterThrowing("execution(* com.demo.PerformanceI.perform(..))")  
    public void afterThrowing(){  
    System.out.println("【非常醒目 [方法异常后] 】");  
    }  
} 

配置文件

import com.demo.*;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.ComponentScan;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.context.annotation.EnableAspectJAutoProxy;  
  
@Configuration  
@EnableAspectJAutoProxy  
@ComponentScan("com.demo")  
public class AppConfig {  
    @Bean  
    public MyAspect myAspect() {  
        return new MyAspect();  
    }  
     
}  

测试用例

import org.junit.Test;  
import org.junit.runner.RunWith;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.test.context.ContextConfiguration;  
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes = AppConfig.class)  
public class MyTest {  
  
    @Autowired  
    private PerformanceI p1;  
      
    @Test  
    public void play() {  
        p1.perform();  
    }  
}  

此时在本地运行报错··········

 后来加入了  aopalliance.jar 包后解决问题 已经写入到 博客园内 问题3.

实现了方法调用前后的AOP效果。

 

这个Spring官方参考做的不错：http://docs.spring.io/spring/docs/4.2.5.RELEASE/javadoc-api/

这里选不同的版本：http://docs.spring.io/spring/docs/

 4.3.2 创建环绕通知

哈哈此小结个人觉得挺有意思所以也就拿上来了。

环绕通知是最为强大的通知类型。它能够让你所编写的逻辑将被通知的目标方法完全包装起 来。实际上就像在一个通知方法中同时编写前置通知和后置通知。

环绕通知，直接上代码说事情。

package concert;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;  
@Aspect  
public class MyAspect {
    @Pointcut("execution(* concert.PerformanceI.perform(..))")
    public void perform(){}
    @Around("perform()")
    public void watchPerformance(ProceedingJoinPoint jp){  
        try{
            System.out.println("【非常醒目 [方法调用前] 】"); 
            jp.proceed();
            System.out.println("【非常醒目 [方法调用后] 】");  
        } catch (Throwable e){
            System.out.println("【非常醒目 [方法异常后] 】");  
        }
    }  
}

@Around 是环绕通知的 注释，ProceedingJoinPoint 作为参数用来通知“自己想做的业务逻辑” 个人理解就是切点。
粘贴过来一张原图，是通过XML配置来实现AOP切面功能，跟上面  通过基于AspectJ注解 @EnableAspectJAutoProxy 引入是一个意思。  

3.Spring MVC

DispatcherServlet是Spring MVC的核心，每当应用接受一个HTTP请求，由DispatcherServlet负责将请求分发给应用的其他组件。

首选给出一张Spring MVC的组件图，也是Spring mvc 的流程图

在旧版本中，DispatcherServlet之类的servlet一般在web.xml文件中配置；但是Spring 3.1引入了注解就无需再使用web.xml文件。

 下面配置DispatcherServlet 

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;  
  
public class SpitterWebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {  
  
    @Override  
    protected Class<?>[] getRootConfigClasses() {  
        return new Class<?>[]{RootConfig.class};  
    }  
  
    @Override  
    protected Class<?>[] getServletConfigClasses() {  
        return new Class<?>[]{WebConfig.class};  
    }  
  
    @Override  
    protected String[] getServletMappings() {  
        return new String[]{"/"};  
    }  
  
}