spring学习笔记（二）

bean的生命周期方法：
IOC对bean生命周期进行管理的过程：
1.通过构造器创建bean实例
2.为bean的属性设置值和对其他bean的引用
3.调用bean的初始化方法
4.bean可以使用了
5.容器关闭时，调用bean的销毁方法
init-method=”“和destroy-method=“”属性，为bean指定初始化和销毁方法

bean的后置处理器：1.实现 implement BeanPostProcess接口，并具体实现 postProcessBeforeInitialization ( )：【init-method之前被调用 】 和postProcessAfterInitialization( )方法

实例工厂的方法：即先需要创建工厂本身，在调用工厂的实例方法来返回bean的实例
public class InstanceCarFactory{
    private Map<String, car> cars=null;
    public InstanceCarFactory(){
        cars=new HashMap<String,car>
        cars.put("audi",new Car("audi",300000));
        cars.put("ford",new Car("ford",400000));
}
    public car getCar(String brand){
        return cars.get(brand)
}
}
//配置工厂实例
<bean id="carFactory" calss="----factory.InstanceCarFactory">
//通过实例工厂方法来配置bean,factory-bean属性：指向实例工厂方法的bean
//factory-method:指向静态工厂方法的名字
<bean id="car2" factory-bean="carFactory" factory-method="getCar">
    <constructor-arg value="ford"></constructor>
</bean>
Main(){}输出

通过FactoryBean配置bean
1.实现FactoryBean接口;属性 brand
2.配置

<bean id="car" class="---CarFactory">
    <property name="brand" value="BMW"></property>
</bean>

3.main:输出bean

基于注解的方式配置bean：
特定组件：@Component:基本注解，标识了一个受Spring管理的组件
@Respository:标识持久层组件
@Service：标识业务层组件
@Controller:标识表现层组件
@Autowire @resource

context:exclude-filter：子节点指定排除哪些指定表达式的组件
context:include-filter：子节点指定包含哪些表达式的组件，需要use-default-filters=”false”配合使用

<context:component-scan
    base-package=""//指定一个需要扫描的基类包
    resource-pattern=""//仅希望扫描特定的类/>
    <context:exclude-filter type="annotation" expression="-----不包含的包名">
</context:component-scan>

<context:component-scan
    base-package=""
    use-default-filters="false"
    <context:include-filter type="annotation" expression="-----指定包含的包名">
</context:component-scan>

AOP
1.建一个接口（加，减，乘，除）
2.实现接口
3.每个方法实现前写一个日志，实现后写一个日志
代码混乱，代码分散
使用动态代理解决上述问题
原实现类不变；
新建类：动态代理类

public class ArithmeticCalculatorLoggingProxy{
    private ArithmeticCalculator target;//要代理的对象
    public  AritnmaticCalculator getLoggingProxy(){
        AritnmaticCalculator proxy=null；
        //代理对象由哪一个类加载器负责加载
        ClassLoader loder=target.getClass().getClassLoader();
        //代理对象的类型，即其中有哪些方法
        Class[] interfaces=new Class[ArithmeticCalculator.class]
        //档调用代理对象其中的方法时，该执行的代码
        InvocationHandler h=new InvocationHandler(){
            //proxy:正在返回的那个代理对象，一般情况下，在invoke方法中都不使用该对象
              method：正在被调用的方法
                @Ovewwide
                public Object invoke(Object proxy;Method method,Object[] args)throws Throwable{
                    String methodName=method.getName();
                    //日志
                    SysOUT(methodName+"开始"+Arrays.aslist(args));
                    //执行方法
                    Objict result=method.invoke(target,args);
                    //日志
                    SysOUT(methodName+"结束"+result);
          }
   }
        proxy=(AritnmaticCalculator)proxy.newProxyInstance(loader,interfaces,h);
        return proxy;
}
}

AOP:
前置日志，后置日志为一个切面
验证参数为一个切面
通知：切面必须完成的工作
连接点：方法执行点；相对点表示的方位（物理存在）
切点： 链接点相当于数据库中的记录，切点相当于查询条件
spring AOP:
1.新建lib，导入jar包：aopalliance;aspectj.weaver;logging;aop;aspects;beans;context;core;expression
2.applicationcontext.xml

日志切面：
//把这个类声明为一个切面：1.放入IOC  2.在声明为一个切面
@Aspect
@Component
public class LoggingAspect{
    //声明该方法是一个前置通知：在目标方法开始之前执行
     @Before("execution(public 包名)")
     public void beforeMethod(){
     sysout("begin")}
 }
 xml中：
 <!--使AspjectJ注解起作用：自动为匹配的类生成代理对象-->
 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

后置通知：目标方法执行后@after