Java学习笔记（二十九）：spring

spring配置

1. 分层的 Java SE/EE 框架

2. 内核：ioc、aop

ioc具体实现：依赖注入

aop具体实现：

3. 技术：持久层 Spring JDBCTemplate、业务层 事务管理、展示层 Spring MVC

4. 过程：spring框架 读取xml文件，通过反射创建bean对象，返回对象

5. <bean>的属性：

id  ---唯一

class  ---类全名称

scope  ---范围：singleton单例（读取xml文件时创建bean）、prototype多例（getBean时创建）

init-method  ---指定初始化方法

destory-method  ---指定销毁方法

------默认无参构造方法初始化bean，工厂方式初始化bean时需要自定义一个工厂类，写个getDao方法

  factory-method  ---静态工厂 方式 初始化bean（class自定义的工厂类）

  factory-bean  ---动态工厂方式初始化bean（factory-bean="工厂类的beanid"  factory-method="getDao"）

6. 依赖注入：control层 只使用 service，service又依赖dao；所以再spring容器内部将dao注入service

带参构造方法：service中定义：dao的私有变量、带参（dao）的构造方法

                           xml：<consturctor-arg  name="参数名"  ref="dao的id">

set方法：service中定义：dao的私有变量、dao的set方法

                 xml：<property  name="属性名"  ref="dao的id">

补充：property可以改为属性p:userDao-ref="xxx"，需要引入p命名空间

7. set注入其它类型：

普通类型：<property  name="属性名"  value="值">

引用类型：property的字标签：

                   <list>  <value>值</value>（引用：<ref>引用的id值</ref>） ......</list>

                   <map>  <entry  key="key值"   value-ref="引用的id值"> </entry> .......</map>

                   <props>  <prop  key="key值"> value值 </prop> .......</props>

引用的赋值：在配置对应的bean时（如user的bean），用property赋好值

8. 在主配置文件中引入其它配置文件：<import  resource="xxx.xml">

9. API

接口：ApplicationContext

实现类：ClassPathXml......  从类的根目录下加载配置文件

                FileSystemXml.......  从磁盘加载配置文件

                AnnotationConfig......  读取注解，用注解配置容器对象

方法：getBean

getBean的参数：String类型：id名

                              Class<T>类型：类的字节码（这个类型在容器中只有一个bean）

10. 配置数据源

.properties配置文件中配置连接信息

.xml配置文件中读取连接信息，将数据源（如 DruidDataSource）注入Spring容器

使用：DataSource dataSource = app.getBean(DataSource.class);

//补充：读取properties配置文件的方法之一
ResourceBundle rb = ResourceBundle.getBundle("jdbc"); //配置文件名
String str=rb.getString("key的名")

//xml配置文件

    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driverClassName}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${username}"></property>
        <property name="password" value="${password}"></property>
        <property name="initialSize" value="${initialSize}"></property>
        <property name="maxActive" value="${maxActive}"></property>
        <property name="maxWait" value="${maxWait}"></property>
    </bean>

//使用
DataSource dataSource = app.getBean(DataSource.class);

spring注解

1. 需要在xml中配置组建扫描：<context:component-scan base-package="该包及其子包" />

2. 原始注解：代替bean

@Component ---类上，放入容器（对应三个语义化注解：@Controller、@Service、@Repository）

@Scope ---类上，作用范围

@PostConstruct ---方法上，初始化方法；@PreDestory ---方法上，销毁方法

@Value ---变量上，普通变量注入，（"变量值 / ${key的值}"）

@Autowired ---变量上，引用注入，根据类型注入

@Qualifier ---变量上，引用注入，根据名称注入（与Autowired一起用），可省略set方法

@Resource ---变量上，引用注入，等于Autowired+Qualifier，（name="名"）

3. 新注解

@Configuration ---类上，总配置类

@ComponentScan ---类上，组建扫描，（"包"）

@PropertySource ---类上，加载.properties文件，（"classpath:jdbc.properties"）

@Import ---类上，导入配置类，（{xx.class,...}）

@Bean ---方法上，方法返回值存到spring容器中，（"指定名称"），例如：返回dataSource

4. 整合Junit

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
//@ContextConfiguration(classes={SpringConfiguration.class})
public class SpringTest {

    @Autowired
    private UserService userService;

    @Test
    public void test01(){
        userService.out();
    }
}

spring的aop

1. aop：面向切面编程；是通过预编译的方式和运行期动态代理实现程序功能的统一维护的一种技术

              是oop（面向对象编程）的延续

             aop是一种思想，spring框架对aop思想进行实现，aspectj框架也对aop思想进行实现，且性能更好

2. 底层实现：动态代理技术（自动实现）

JDK代理：基于接口

cglib代理：基于类

spring监听切点的执行，切点被执行---使用代理机制，动态创建目标对象和代理对象---根据通知类别，在代理对象的对应位置，将通知对应的功能织入

3. 一些名词：

目标对象、代理、连接点（可以被增强的方法）、切入点（切点；真正被增强的方法）

通知/增强（增加的代码）、切面（目标方法+增加的代码；切点+通知）

织入（将切面和增强结合到一起的过程）

4. xml方式：

    <!--配置织入-->
    <aop:config>
        <aop:aspect ref="myaspect"> <!--切面类id-->
            <!--切点表达式 ： 类型 包.类.方法(参数)-->
            <aop:pointcut id="be" expression="execution(* service.impl.*.*(..))"></aop:pointcut>
            <!--before 前置增强-->
            <aop:before method="outBefore" pointcut-ref="be"></aop:before>
        </aop:aspect>
    </aop:config>

before 前置、after-returning 后置、around 前(切点方法)后(方法返回值)、throwing 异常、after 最后(无论有无异常)

around参数：ProceedingJoinPoint 切点，可以用它调用切点方法

5. 注解方式：

加AOP自动代理：<aop:aspectj-autoproxy />

@Aspect 切面类

@Before、@AfterReturning、......  ("切点表达式")或者("类.方法()")

@PointCut("切点表达式")  用在一个空方法上，是表达式抽取

 

Spring JDBCTemplate

1. new JdbcTemplate()-->xml <bean>

  setDataSource(ds)-->set注入

 

事务控制

1. 声明式事务控制：xml、注解

              底层就是aop

              看作切面：切点--业务方法，通知--事务控制（开启事务、提交、回滚）

    <!--平台事务管理器-->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--事务-->
    <tx:advice id="interceptor" transaction-manager="dataSourceTransactionManager">
        <!--针对各个业务方法，设置事务的属性信息-->
        <tx:attributes>
            <!--方法名、*、方法名*-->
            <tx:method name="*" isolation="DEFAULT" propagation="REQUIRED" timeout="-1" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    <!--事务 配置织入-->
    <aop:config>
        <!--事务专用-->
        <aop:advisor advice-ref="interceptor" pointcut="execution(* service.impl.*.*(..))"></aop:advisor>
    </aop:config>

2. 注解：@Transactional  类上--针对所有方法，方法上--优先

    xml写注解驱动

<tx:annotation-driven transaction-manager="dataSourceTransactionManager"></tx:annotation-driven>