Spring学习笔记

在配置好需要的文件后就可以进行编程学习了。。
Spring基于XML文件配置Bean的方法：
在IOC容器中配置：

 
 
      //属性注入
 
  //构造器注入
 
   //和上例效果相同
 
 
 
 

1.创建spring的IOC容器
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
2.从IOC容器中获取Bean的实例
HelloWorld helloWorld=(HelloWorld)ctx.getBean(HelloWorld.class); //只能有一个HelloWorld类型的Bean

HelloWorld helloWorld=ctx.getBean("helloWorld");

属性配置细节
1.当要给变量赋值特殊符号时可用包裹起来。
2.属性值也可以用 value 直接点进行配置
3.可以使用property的 ref 属性建立 bean之间的引用关系。
4.内部 Bean 不能被外部影响，只能内部使用。
5.可以使用 标签为某些属性注入 null 值
6.使用级联属性赋值时，必须先初始化后才可以为级联属性赋值，当前 Bean 内必须有 get和set -ref对象的方法。
7.使用标签时，若引用的 Bean 是另一个包里的同名类，则应 import 另一个包的该同名类。
8.使用 util 标签来配置单例的集合bean，以供多个bean进行引用，需要导入util命名空间。
9.使用 P命名空间为 bean 的属性赋值，需要导入p命名空间。相对于传统的方式更加简洁。
格式 ：
10.可以使用 autowire 自动装配，有byName,byType,constructor等方式。
autowire="byName">

11.bean之间的关系：bean 可以继承 (parent)、依赖（depends-on），bean的abstract属性为true，这样的bean不能被IOC容器实例化，只用来被继承配置
不会继承 bean 的所有属性，例如：autowire、abstract……若某一个bean的 class 属性没有指定，则该 bean 必须是一个抽象 bean。
depends-on 属性会将 前置依赖的Bean在本Bean实例化之前创建好。如果依赖于多个Bean，则可以通过 逗号、空格 配置Bean的名称。
12.Bean的作用域 : 可以用 scope 属性配置。 singleton 是默认值，容器初始时创建实例，在整个容器生命周期内至创建这一个 bean。 prototype 是原型的，容器初始化时不创建 bean 的实例，而是在每次请求时创建新的 bean实例并返回。
13.可以使用外部属性文件配置Bean。 .
14.SpEL : 可以使用 SpEL 来给 Bean 配置 。
(1) 当要给 字符串类型赋值时 : value="#{'abc'}"
(2) 当赋 整型、浮点型时 ： value="#{14}" value="#{123.321}"
(3) 当引用其他 属性时 ： value="#{car}" value="#{car.price}"
(4) 当引用类的静态属性时： value="#{T(java.lang.Math).PI*8}"
(5) 当使用运算符时： value="#{ 10>5? '大于' : '小于' }"

15. 可以自行设置 Bean 的 init（）方法 和 destroy（） 方法。 先在 Bean Class 里将init()和destroy()方法写好，名字自订，然后在xml文件里配置。
    例：

16.可以添加 Bean后置处理器。通过写一个 BeanPostProcessor 接口类，然后在里面重写 postProcessAfterInitialization（init后执行）和postProcessBeforeInitialization（init前执行） 方法，并在xml文件里配置。
例：

17.可以使用静态工厂方法配置bean：先创建一个静态工厂方法类，例：

public class StaticGameFactory {
private static Map games=new HashMap();
static{
    games.put("ChiJi", new Game("ChiJi",98));
    games.put("H1Z1", new Game("H1Z1",68.0));
}
//静态工厂方法
public static Game getGame(String name){
    return games.get(name);

然后在xml文件里通过静态工厂方法来配置bean。
例：

  
    //如果工厂方法需要传入参数，则使用constructor-arg来配置参数

18.也可以使用实例工厂方法配置bean：

public class InstanceGameFactory {
private Map games;
public InstanceGameFactory(){
    games=new HashMap();
    games.put("CF", new Game("CF",0));
    games.put("dnf", new Game("dnf",1));
}
public Game getGame(String name){
    return games.get(name);
}

需要先配置工厂的实例：

然后再配置 bean 实例： //factory-bean 指向实例工厂方法的bean factory-method指向实例工厂方法的名字; 如果工厂方法需要传入参数，则使用constructor-arg来配置参数

19.通过FactoryBean 来配置 bean。 首先自定义FactoryBean,需要实现FactoryBean 接口，然后在xml文件里 通过 FactoryBean 来配置Bean的实例，例：
class:指向FactoryBean的全类名；property：配置FactoryBean的属性； 实际返回的是 FactoryBean 的 getObejct() 方法的实例

20.通过注解配置Bean

使用@Autowired自动装配Bean
一般情况下，所有使用@Autowired注解的属性都要被设置，当Spring找不到匹配的Bean时，会抛出异常，若某一属性允许不被设置，可以设置@Autowired 注解的 required 属性 为fasle。
默认情况下，当IOC容器里存在多个类型兼容的 Bean 时，通过类型的自动装配将无法工作，此时可以在 @Qualifier 注解里提供 Bean 的名称，Spring 允许对方法的形参标注 @Qualifier 以指定注入 Bean 的名称。
--@Autowired 注解也可以应用在 数组类型 的属性上，此时Spring 会把所有匹配的 Bean 进行自动装配。
--@Autowired 注解也可以应用在 集合属性 上，此时Spring 读取该集合的类型信息，然后自动装配所有与之兼容的 Bean。
--@Autowired 注解用在 java.util.Map 上时，若该 Map 的键值为 String ，那么 Spring 将自动装配与之 Map 值类型兼容的 Bean ，此时Bean 的名称作为键值。

21.泛型依赖输入

public class BaseService {
@Autowired
private BaseRepository baseRepository;
public void add(){
    System.out.println("add...");
    System.out.println(baseRepository);
}
}
@Service
public class UserService extends BaseService{
}
@Repository
public class UserRepository extends BaseRepository{
}

当 userService 调用 add 方法时，会输出
add...
com.spring.beeans.generic.di.UserRepository@2449a2da
22.动态配置（AOP基础）：

public class ArithmeticCalculatorLoggingProxy {
//要代理的对象
private ArithmeticCalculator target;
public ArithmeticCalculatorLoggingProxy (ArithmeticCalculator target) {
    this.target=target;
}
public ArithmeticCalculator getLoggingProxy(){
    //要代理的对象
    ArithmeticCalculator proxy ;
    //代理对象由哪一个类加载器负责加载
    ClassLoader loader= target.getClass().getClassLoader();
    //代理对象的类型，即其中有哪些方法
    Class[] interfaces=new Class[]{ArithmeticCalculator.class};
    //当调用代理对象其中的方法时，该执行的代码
    InvocationHandler h=new InvocationHandler() {
       @Override
       /*
        * proxy:正在返回的那个代理对象，一般情况下，在 invoke 方法中都不使用该对象
        * method：正在被调用的方法
        * args：调用方法时，传入的参数
        */
       public Object invoke(Object proxy, Method method, Object[] args)
               throws Throwable {
           System.out.println("invoke...");
           //日志
           System.out.println("The method "+method.getName()+" begins with "+Arrays.asList(args));
           //执行方法
           Object result=method.invoke(target, args);
           //日志
           System.out.println("The method "+method.getName()+" ends with "+result);
           return result;
       }
    };
    proxy=(ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
    return proxy;
  }
}
  public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
public int add(int i, int j) {
    return i+j;
}
public int sub(int i, int j) {
    // TODO Auto-generated method stub
    return i-j;
}
public int mul(int i, int j) {
    // TODO Auto-generated method stub
    return i*j;
}
public double div(double i, double j) {
    return i/j;
}
}
public class Main {
public static void main(String[] args) {
ArithmeticCalculator target=new ArithmeticCalculatorImpl();
ArithmeticCalculator proxy=new ArithmeticCalculatorLoggingProxy(target).getLoggingProxy();

System.out.println(proxy.getClass().getName());

int result=proxy.add(1, 2);
System.out.println(result);

result=proxy.sub(3, 1);
System.out.println(result);
}
}  

输出结果为：
com.sun.proxy.$Proxy0
invoke...
The method add begins with [1, 2]
The method add ends with 3
3
invoke...
The method sub begins with [3, 1]
The method sub ends with 2
2
23.（1）SpringAOP
①加入JAR包 ②在配置文件中加入 aop 的命名空间
③基于注解的方式：
i.在配置文件中加入如下配置：

AOP类：

@Aspect
public class LogginPerformance {
   @Pointcut("execution(** com.aop.Performance.perform(..))")
   public void cut() {}
   
   @Before("cut()")
   public void beforeMethod() {
         System.out.println("Before");
   }
}

代理对象类：

package com.aop;
public interface Performance {
     public void perform();
}

还需要讲implements 该接口类的 类 加入扫描对象

package com.aop;
@Component
public class Singer implements Performance{
@Override
public void perform() {
    System.out.println("唱歌");
}
}

使用方法：

package com.aop;
@Component
public class TestAOP {
public static void main(String[] args) {
   ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
   Performance p=ctx.getBean(Performance.class);
   p.perform();
}
}