《学透Spring》

1
2
3

<beans xxx>
    <bean id="hello" class="learning.spring.helloworld.Hello" />
</beans>

1
2
3
4
5
6
7
8

// 根据xml文件初始化BeanFactory
BeanFactory beanFactory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
reader.loadBeanDefinitions("beans.xml");
// 从IoC容器中读取Bean（两种方式）
// Hello hello = (Hello) beanFactory.getBean("hello");
Hello hello = beanFactory.getBean("hello", Hello.class);
hello.sayHello();

1
2
3
4
5

// 根据xml文件初始化容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
// 从IoC容器读取Bean
Hello hello = applicationContext.getBean("hello", Hello.class);
hello.sayHello();

1
2

ApplicationContext parentContext = new ClassPathXmlApplicationContext("parent-beans.xml");
ApplicationContext childContext = new ClassPathXmlApplicationContext(new String[]{"parent-beans.xml"}, true, parentContext);

1

<bean id="xxx" class="learning.Spring.Yyy" factory-method="create" />

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Java类的容器配置
@Configuration
@ComponentScan("learning.Spring") // 可省略，默认Config所在包
public class Config{
    @Bean
    @Lazy
    @Scope("prototype")
    public Hello helloBean(){return new Hello();}
}

// 初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);

1
2
3
4
5
6
7

public class  Hello implements DisposableBean{
    @PreDestroy
    public void shutdown(){}
    @Override
    public void destroy() throws Exception{}
    public void close(){}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 方式1：实现ApplicationListener接口方式
@Component
@Order(1)
public class ContextClosedEventListener implements ApplicationListener<ContextClosedEvent>{
    @Override
    public void onApplicationEvent(ContextClosedEvent event){}
}
// 方式2：用注解@EventListener方式
@Component
public class ContextClosedEventAnnotationListener{
    @EventListener
    @Order(2)
    public void onEvent(ContextClosedEvent event){}
}

1
2
3
4
5
6

public class Hello implements Lifecycle{
    @Override
    public void start(){}
    public void stop(){}
    public boolean isRunning(){}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 接口定义
public interface Hello{
    void say();
}
// 原始实现
public class SpringHello implements Hello{
    @Override
    public void say(){
        System.out.println("Hello Spring!");
    }
}
// 代理处理类
public class LogHandler implements InvocationHandler{
    private Hello source;
    public LogHanlder(Hello source){this.source = source;}
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        System.out.println("Ready to say somethind.");
        try{
            retrun method.invoke(source, args);
        } finally {
            System.out.println("Already say something.");
        }
    }
}
// 调用样例
public class Application{
    public static void main(String[] args){
        Hello orginal = new SpringHello();  // 原始实现
        Hello target = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(),
            original.getClass().getInterfaces(), new LogHanlder(original)); // 代理实现
        target.say();   // 发起代理调用
    }
}

1
2
3
4
5
6
7

public class Hello{
    public void foo(){
        bar();
    }
    public void bar(){}
}
// 哪怕AOP对bar做了拦截，由于调用的不是代理对象，因而看不到任何效果

1

execution([修饰符] <返回类型> [全限定类型.]<方法>(<参数>) [异常])

1
2
3
4
5
6
7

@Aspect
public class BeforeAspect{
    @Before("learning.spring.helloworld.HelloPointcut.sayHello()")
    public void before(){
        System.out.println("Before Advice");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

@AfterReturning("execution(public * say(..))")
public void after(){}

@AfterReturning(pointcut = "execution(public * say(..))", returning = "words")
public void printWords(String words){
    // returning指定的字段自动绑定同名通知参数
}

@AfterThrowing("execution(public * say(..))")
public void afterThrow(){}

@AfterThrowing("execution(public * say(..))", throwing="exception")
public void afterThrow(Exception exception){
    // throwing指定的字段自动绑定同名通知参数
}

@After("execution(public * say(..))")
public void afterAdvice(){} // 不关心返回值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@Around("execution(public * say(..))")
public Object recordTime(ProceedingJoinPoint pjp) throws Throwable{
    long start = System.currentTimeMillis();
    try{
        return pjp.proceed();   // 对具体连接点进行处理
    }finally{
        long end = System.currentTimeMills();
        System.out.println("Total time: " + (end - start) + "ms");
    }
}

1
2
3
4
5
6

@Aspect
public class MyAspect{
    @DeclareParents(value="learning.spring.helloworld.Hello",// 目标增强的Bean类型
        defaultImpl = DefaultGoodByeImpl.class) // 新增接口的方法的默认实现
    private GoodBye goodBye;    // 新增拓展的接口
}

1
2
3
4
5
6
7
8

public interface Hello{
    String sayHello(StringBuffer words);
}
@Component
public class SpringHello implements Hello{
    @Override
    public String sayHello(StringBuffer words){return "hello! " + words;}
}

1
2
3
4
5
6
7
8
9

@Aspect
@Component
@Order(1)
public class HelloAspect{
    @Before("target(learning.spring.helloworld.Hello) && args(words)")  // 绑定参数words
    public void addWords(StringBuffer words){
        words.append("Welcome to Spring!");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

@Aspect
@Component
@Order(2)
public class SayAspect{
    @DeclareParents(value="learning.spring.helloworld.*",// 目标增强的Bean类型
            defaultImpl = DefaultGoodBye.class) // 新增接口的方法的默认实现
    private GoodBye goodBye;    // 新增拓展的接口

    private int count = 0;

    @Beofre("excution(* say*(..)) && args(words)") // 绑定参数words
    public void countSentence(StringBuffer words){words.append("["+ ++count + "]\n");}

    @Around("excution(* say*(..)) && this(bye)") // 以GoodBye的类型绑定bye
    public String addSay(ProceedingJoinPoint pjp, GoodBye bye) throws Throwable{
        return pjp.proceed() + bye.sayBye();
    }

    public void reset(){counter = 0;}
    public int getCounter(){return counter;}
}

1
2
3
4
5
6
7

public interface GoodBye{
    String sayBye();
}

public DefaultGoodBye implements GoodBye{
    public String sayBye(){return "Bye!";}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

@Configuration
@EnableAspectJAutoProxy
@ComponenctScan("learning.spring.helloworld")
public class Application{
    public static void main(String[] args){
        AnnotationConfigAplicationContext applicationConext = 
            new AnnotationConfigAplicationContext(Application.class);
        Hello hello = applicationContext.getBean("springHello", Hello.class);
        System.out.println(hello.sayHello(new StringBuffer("My Friend. ")));
        // Hello! My Friend. Welcome to Spring![1]\nBye!
        System.out.println(hello.sayHello(new StringBuffer("My Dear Friend. ")));
        // Hello! My Dear Friend. Welcome to Spring![2]\nBye!
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

<aop:config>
    <aop:aspect ref="helloAspect" order="1">
        <aop:before pointcut="target(learning.spring.helloworld.Hello) and args(words)"
            method="addWords"/>
    </aop:aspect>
    <aop:aspect ref="sayAspect" order="2">
        <aop:before pointcut="execution(* say*(..)) and args(words)" method="countSentence" />
        <aop:around pointcut="execution(* sayHello(..)) and this(bye)" method="addSay" />
        <aop:declare-parents types-mathcing="learning.spring.helloworld.*"
            implements-interface="learing.spring.helloworld.GoodBye"
            default-impl="learning.spring.hellowrold.DefaultGoodBye" />
    </aop:aspect>
</aop:config>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Application{
    public static void main(String[] args){
        AplicationContext applicationConext = 
            new ClassPathXmlApplicationContext("applicationContext.xml");
        Hello hello = applicationContext.getBean("springHello", Hello.class);
        System.out.println(hello.sayHello(new StringBuffer("My Friend. ")));
        // Hello! My Friend. Welcome to Spring![1]\nBye!
        System.out.println(hello.sayHello(new StringBuffer("My Dear Friend. ")));
        // Hello! My Dear Friend. Welcome to Spring![2]\nBye!
    }
}