Java.Web学习笔记 Spring4

Spring4
1. HelloWorld例程
（1） 先导入Jar包
（2） 然后在applicationContext.xml中配置Beans
（3）

//1. 创建Spring的IOC容器对象（这时候就会创建对象了，调用set方法和构造方法）
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");  

（4）

//2. 从IOC容器中获取Bean实例
HelloWorld helloWorld=(HelloWorld) ctx.getBean("helloWorld");

（5）

//3. 调用hello()方法
helloWorld.hello();

1. IOC（Inversion of Control）反正资源获取方向，容器主动将资源推送给它所管理的组件，组件只要选择一种合适的方式接受资源
2. DI（Dependency Injection）-依赖注入，IOC的另一种表述方式，组件以一些预先定义好的方式（Setter方法）进行注入资源
3. Bean的获取

//id方式定位IOC容器中的Bean
HelloWorld helloWorld=(HelloWorld) ctx.getBean("helloWorld");
//class方式定位IOC容器中的Bean，要求IOC中只有一个该类型的Bean
HelloWorld helloWorld=ctx.getBean(HelloWorld.class);

1. IOC容器
   BeanFactory：IOC的基本实现
   ApplicationContext 提供了更多高级特性，是BeanFactory的子接口，一般开发使用这个
2. 依赖注入方式
   （1） 属性注入
   （2） 构造器注入
   

<!—属性值除了可以用value属性配置还可以用<value>节点配置 -->
    <constructor-arg  type="java.lang.String">
        <value><![CDATA[<Shanghai>]]></value>
</constructor-arg>

（3） 工厂方法注入（很少使用，不推荐）
7. Bean之间的引用

<!-- 使用property的ref属性建立引用关系 -->
        <property name="car" ref="car2"></property>

1. 内部Bean

<!-- 内部Bean， 不能被外部引用，只能在内部使用 -->
        <property name="car">
            <bean class="spring.beans.Car">
                <constructor-arg value="BieKe" index="0"></constructor-arg>
                <constructor-arg value="ShangHai" index="1"></constructor-arg>
                <constructor-arg value="350000" index="2"></constructor-arg>
            </bean>
        </property>

1. Null值

<constructor-arg ><null/></constructor-arg>

1. 级联属性赋值

<!-- 为级联属性赋值，注意属性需要先初始化，后才可以级联赋值，否则会有异常，和Struts2不同 -->
        <property name="car.price" value="30000"></property>

1. 集合属性
   用list标签定义集合属性，可以用ref，也可以用内部bean

<property name="cars">
            <!-- 使用list 节点为list类型的属性赋值 -->
            <list>
                <ref bean="car"/>
                <ref bean="car2"/>
                <bean class="spring.beans.Car">
                    <constructor-arg><null /></constructor-arg>
                    <constructor-arg value="ShangHai" index="1"></constructor-arg>
                    <constructor-arg value="350000" index="2"></constructor-arg>
                </bean>         
            </list>
</property>

1. Map属性
   

<map>   
        <entry key="AA" value-ref="car"></entry>
        <entry key="BB" value-ref="car2"></entry> 
</map>

1. Properties的属性

  <!-- 配置Properties属性值 -->
    <!-- 使用props和prop子节点来为Properties属性赋值 -->
    <bean id="dataSource" class="spring.beans.collection.DataSource">
        <property name="properties">
            <props>
                <prop key="user">root</prop>
                <prop key="password">ljt123456</prop>
                <prop key="jdbcUrl">jdbc:mysql://localhost:3306/test</prop>
                <prop key="driverClass">com.mysql.jdbc.Driver</prop>
            </props>
        </property>
    </bean>
14. 用utility把bean配置成独立的，然后可以被其他bean引用
<!-- 配置独立的集合 -->
    <util:list id="cars">
        <ref bean="car"/>
        <ref bean="car2"/>
    </util:list>

1. P命名空间简洁配置属性

<!-- 通过p命名空间为bean属性赋值 -->
    <bean id="person5" class="spring.beans.collection.Person" 
    p:age="30"
    p:name="JanathonL"
    p:cars-ref="cars"></bean>

1. 自动装配（autowire）

<!-- 
        可以使用autowire属性指定自动装配的方式，
        byName根据bean的名字和当前bean的setter风格属性名自动装配，如果有匹配的就自动装配，如果没有匹配的就为null 
        byType根据bean的类型和当前bean的setter属性名自动装配。若IOC容器中有1个以上的类型匹配的Bean，则抛异常
    -->
    <bean id="person" class="spring.beans.autowire.Person" p:name="Tom"
        autowire="byType"></bean>
缺点：
        如果在一个bean中使用了autowire，那所有引用的都得是用自动装配

1. 继承bean

<!-- bean 配置的继承：使用bean的parent 属性指定继承哪个bean的配置 -->
    <bean id="address2" p:street="DaZhongsi" parent="address"></bean>

1. 抽象bean：bean的属性abstract为true的bean，不能被IOC实例化，只能用来被继承、
2. 依赖前置bean

<!-- 要求在配置Person 时，必须有一个关联的car！ person这个bean依赖于Car这个bean -->
    <bean id="person" class="spring.beans.autowire.Person" p:name="Tom"
        p:address-ref="address" depends-on="car"></bean>

1. Bean的scope
   
2. 使用外部属性文件

<!-- 导入属性文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${user}"></property>
        <property name="password" value="${password}"></property>
        <property name="driverClass" value="${driverClass}"></property>
        <property name="jdbcUrl" value="${jdbcUrl}"></property>
</bean>

1. SpEL语言使用#{…}作为界定符，所有大括号中的字符都被认为是SpEL
    引用Bean、属性和方法
   （1） 引用Bean
   （2） 引用其他对象的属性
   （3） 引用其他方法还可以链式操作

<!-- 使用SPEL引用类的静态属性 -->
        <property name="tyrePerimeter" value="#{T(java.lang.Math).PI*80}"></property>

    <bean id="person" class="spring.beans.spel.Person">
        <!-- 使用SpEL来引用其他的bean -->
        <property name="car" value="#{car}"></property>
        <property name="city" value="#{address.city}"></property>
        <property name="info" value="#{car.price > 300000? '金领' : '白领'}"></property>
        <property name="name" value="Tom"></property>
    </bean>

1. 创建Bean后置处理器
   
   
   
2. 通过工程方法配置bean
    静态工厂方法
   
   

    <bean id="car1" class="spring.beans.factory.StaticCarFactory"
        factory-method="getCar">
        <constructor-arg value="audi"></constructor-arg>
</bean>

 实例工厂方法

<!-- 配置工厂的实例 -->
    <bean id="carFactory" class="spring.beans.factory.InstanceCarFactory"></bean>

    <!-- 通过实例工厂来配置bean -->
    <!-- 
        factory-bean属性：指向实例工厂方法的全类名
        factory-method：指向实例方法的名字
        constructor-arg：如果工厂方法需要传入参数，就用这个方式
     -->
    <bean id="car2" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="ford"></constructor-arg>
</bean>

1. FactoryBean方法配置
   

<bean id="car" class="spring.beans.factorybean.CarFactoryBean">
        <property name="brand" value="BMW"></property>
    </bean>

1. 注解配置bean

<!-- 指定Spring IOC 容器扫描的包 -->
    <!-- 可以通过resource-pattern指定扫描的资源 -->
    <!-- context:exclude-filter 子节点指定排除哪些指定表达式的组件 -->
    <!-- context:include-filter 子节点指定包含哪些表达式的组件，该子节点需要use-default-filters 配合使用 -->
    <context:component-scan base-package="spring.beans.annotation"
    use-default-filters="false"
    >
        <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository" 
            /> -->
        <!-- <context:include-filter type="annotation"
            expression="org.springframework.stereotype.Repository" /> -->
        <!--    <context:exclude-filter type="assignable" 
            expression="spring.beans.annotation.repository.UserRepositoryImpl"/> -->
            <context:include-filter type="assignable" expression="spring.beans.annotation.repository.UserRepository"/>
    </context:component-scan>
</beans>

1. 注解配置bean之间的关联可以使用@AutoWired注意要在使用这个注解的bean类中也要有注解配置，不然抛异常，当然如果@AutoWired（required=false）就不会抛异常，该对象找不到就为null
    如果一个autowired可能对应相同类型的多个类，那么需要给指定的类写上bean的名字，通过名字匹配，不然抛异常
   还可以用一个注解@Qualifier里面写类名首字母小写
    泛型依赖注入，泛型父类使用了注解@AutoWired那么到时候子类也可以注入
   AOP

2. 动态代理

3. AOP面向切面编程，切面是横切关注点。

4. AspectJ是Java社区里最完整的AOP框架
    基于注解配置
   1） 加入jar包
   2） 在配置文件中加入aop命名空间，然后配置文件中加入
   
   
   3） 把横切关注点的代码抽象到切面的类中，
   切面首先是一个IOC中的bean，即加入@Component注销
   切面还需要加入@Apect注解
   在类中声明各种通知
   i. 声明一个方法
   ii. 在方法前加入@Before注解
   iii. 可以在声明方法中加入JoinPoint可以让我们访问一些连接细节
   4） 切面有几个通知，前置通知，返回通知，后置通知，异常通知和环绕通知
   5） 可以使用@Order指定切面优先级，值越小优先级越高
   6） 重用切入点表达式

/**
*定义一个方法，用于声明表达式，一般地，该方法中再不需要添入其他的代码了
*使用@Pointcut来声明切入点表达式
*后面的其他通知直接使用方法名来引用当前的切入点表达式
*/
@Pointcut(“execution(public int spring.aop.ArithmeticCalculator.*(int,int))”)
public void declareJoinPointExpression(){
}

 基于xml配置，看看spring-3的工程spring.aop.xml的包就知道了
4. Spring整合hibernate
（1） 有IOC容器来管理Hibernate 的SessionFactory
（2） 让Hibernate使用上Spring的声明式事务
 整合步骤
（1） 先加入Hibernate
I． Jar包
II． 添加Hibernate配置文件：hibernate.cfg.xml
III．
IV．
V．
VI． 编写了持久化类以及对应的.hbm.xml文件
（2） 再加入Spring
I. Jar包
II. 加入Spring的配置文件