spring

Spring设计理念 Spring是面向Bean的编程

Spring 两大核心技术控制反转(IoC：Inversion of Control ) /依赖注入(DI：Dependency Injection ) 面向切面编程(AOP：Aspect Oriented Programming)

//头部信息配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

Spring第一天 
1今天内容的介绍
1.1Spring概念
Spring是一个开源框架，spring是2003年兴起的一个轻量级的Java开发框架，由Rod Johnson创建。简单来说Spring是一个分层的JavaSE/EE一站式轻量级开源框架，使用基本的JavaBean代替EJB。目的是解决企业开发的复杂性，适用范围任何Java应用。
（1）Spring核心两部分：IOC和AOP
IOC：控制反转，比如有一类，在类里面有方法（不是静态的方法），调用类里面的方法，（创建类的对象的过程，需要new出来对象才能调用）。
把对象的创建不是通过new方式实现，而是交给Spring配置创建类对象
AOP：面向切面编程，扩展功能不修改源代码可以实现，

（2）Spring是一站式框架
Spring在JavaEE三层结构中，每一层都提供不同的解决技术
-Web层：Springmvc
-Webservice层：业务处理层
-dao层：Spring的jdbcTemplate

1.2Spring的入门
1、把对象的创建交给Spring进行管理
2、IOC的操作实现有两种方式（xml配置文件和注解方式）
1.2.1IOC底层原理
xml配置文件
dom4j解析xml
工厂设计模式
反射



1.2.2IOC入门案例
第一步 导入jar包
    做spring基本功能，只需导入以下三个jar包
    


第二步 创建类，在类里面创建方法
    


第三步 创建Spring配置文件，配置创建类
（1）Spring核心配置文件名称和位置不是固定的
建议放到src下面，官方建议名称applicationContext.xml
（2）引入schema约束
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!-- <bean/> definitions here -->
</beans>
（3）配置对象创建


第四步 写代码测试对象

1.2.3别名
<beans>
    <alias name="person" alias="p"/>
<bean name="person" class="cn.itcast.aliasspring.Person"/>
</beans>
通过这样的配置，可以达到在一个地方命名，在多个地方使用不同的名字的效果。


1.2.4解决配置文件没有提示
1.Spring引入schema约束,把约束文件引入到myeclipse中
-复制约束文件路径

2.其他标签没有提示也是参考这个操作方法（例如：context，aop，tx 等）
1.3Spring的bean管理（xml配置文件）
1.3.1bean实例化三种方式
第一种 使用类的无参数构造创建对象(重点)


类里面没有无参的构造方法，会出现异常



第二种 使用静态工厂创建
（1）创建静态方法，返回类对象





第三种 使用实例化工厂
（1）创建不是静态方法，返回类对象




1.3.2初始化bean时机
Spring默认在启动时将所有singleton bean提前进行实例化。提前实例化意味着作为初始化的一部分，ApplicationContext会自动创建并配置所有的singleton bean.通常情况下这是件好事。因为这样在配置中有任何错误能立即发现。
Lazy-init=”true or false”
Lazy-init 为false,spring容器将在启动的时候报错（比较好的一种方式）
Lazy-init 为true,spring容器将在调用该类的时候出错。
默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。如：
 <bean id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/>
如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下： 
<beans default-lazy-init="true“ ...>
1.3.3init、destroy
      Spring初始化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法。
  <bean id=“foo” class=“...Foo”
            init-method=“setup”  当bean被载入到容器的时候调用setup
            destory-method=“teardown”/> 当bean从容器中删除的时候调用teardown(scope= singleton有效)，web容器中会自动调用，但是main函数或测试用例需要手动调用
Bean生命周期：
1.instantiate bean对象实例化
2.populate properties 封装属性
3.如果Bean实现BeanNameAware 执行 setBeanName
4.如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setApplicationContext
5.如果存在类实现 BeanPostProcessor（后处理Bean） ，执行postProcessBeforeInitialization
6.如果Bean实现InitializingBean 执行 afterPropertiesSet 
7.调用<bean init-method="init"> 指定初始化方法 init
8.如果存在类实现 BeanPostProcessor（处理Bean） ，执行postProcessAfterInitialization
9.执行业务处理
如果Bean实现 DisposableBean 执行 destroy
10.调用<bean destroy-method="customerDestroy"> 指定销毁方法 customerDestroy


1.3.4bean标签常用属性
（1）id属性：id属性名称任意命名，不能包含特殊字符，id属性不是必须的，但是是唯一的。
（2）class属性：创建对象所在类的全路径
（3）name属性：功能和id属性一样，id属性不能包含特殊字符，但是在name里面可以包含特殊字符。
（4）scope属性：
-singleton ：默认值单例


-prototype ：多例


-request：创建对象把对象放到request域里面
-session：创建对象把对象放到session域里面
-globalSession：创建对象把对象放到globalSession域里面

（5）  autowire属性：byName就是通过Bean的id或者name，byType就是按Bean的Class的类型


1.3.5依赖注入介绍
1.依赖注入就是创建对象的时候，向类的属性里面设置值
2.依赖注入的方式有三种
第一种 使用set方法注入（重点）
public class User{
  private String name;
  public void setName(String name){
  This.name = name;
}
}
User user = new User();
User.setName(“abc”);

第二种 有参数构造注入
public class User{
  private String name;
public User(String name){
  This.name = name;
} 
}
User user = new User(“姗姗”);

第三种 使用接口注入（Spring框架不支持）
public interface Dao{
  public void save(String name);
}
public class DaoImpl implements Dao{
  private String name
  public void save(string name){
  this.name = name;
}
}

1.3.6依赖注入操作
1.3.6.1使用有参构造注入
-index：通过参数顺序
-type：通过参数类型
-name：通过参数名称（3.0以后版本支持）

1.3.6.2使用set方法注入

 
1.3.7Spring注入对象类型属性（重点）
1.创建UserService类和UserDao类
（1）要在UserService里面得到UserDao层的对象
2.具体实现过程
（1）在UserService里面把UserDao作为类型属性
（2）生成UserDao类型属性的set方法

（3）配置文件中的对应关系


1.3.8Spring注入复杂数据
1.数组，List集合，Map集合，Properties
    <!--注入复杂类型属性值  -->
    <bean id="bean" class="com.bw.bean.Bean">
        <!--数组  -->
        <property name="strs">
            <list>
                <value>小王</value>
                <value>大王</value>
            </list>
        </property>
        <!--list  -->
        <property name="list">
            <list>
                <value>xiaoxi</value>
                <value>大海</value>
            </list>
        </property>
        <!--map  -->
        <property name="map">
            <map>
                <entry key="aa" value="bb"></entry>
                <entry key="cc" value="dd"></entry>
            </map>
        </property>
        <!--properties  -->
        <property name="prop">
            <props>
                <prop key="username">root</prop>
                <prop key="pwd">root</prop>
            </props>
        </property>
    </bean>

1.3.9P名称空间注入

1.4IOC和DI区别
（1）IOC：控制反转，把对象创建交给Spring进行配置
（2）DI：依赖注入，向类里面的属性设置值
（3）关系：依赖注入不能单独存在，需要在IOC基础之上完成操作
1.5Spring整合web项目原理
1.加载Spring核心配置文件

（1）new对象，功能可以实现，效率很低
2. 实现思想：把加载配置文件和创建对象过程，在服务器启动的时候完成
3. 实现原理
    （1）ServletContext对象
    （2）监听器
    （3）具体使用：
        -在服务器启动时候，为每个项目创建一个ServletContext对象
        -在ServletContext对象创建时候，使用监听器可以具体到ServletContext对象在什么时候创建
        -使用监听器听到ServletContext对象创建时候
        -加载Spring配置文件，按照配置文件内容创建对象
        -把创建出来的对象放到ServletContext对象域里面（setAttribute()方法）
        -获取对象时候，到ServletContext对象域里面取（getAttribute()方法）

Spring第一天

1 今天内容的介绍

1.1 Spring概念

Spring是一个开源框架，spring是2003年兴起的一个轻量级的Java开发框架，由Rod Johnson创建。简单来说Spring是一个分层的JavaSE/EE一站式轻量级开源框架，使用基本的JavaBean代替EJB。目的是解决企业开发的复杂性，适用范围任何Java应用。

（1） Spring核心两部分：IOC和AOP

IOC：控制反转，比如有一类，在类里面有方法（不是静态的方法），调用类里面的方法，（创建类的对象的过程，需要new出来对象才能调用）。

把对象的创建不是通过new方式实现，而是交给Spring配置创建类对象

AOP：面向切面编程，扩展功能不修改源代码可以实现，

（2） Spring是一站式框架

Spring在JavaEE三层结构中，每一层都提供不同的解决技术

-Web层：Springmvc

-Webservice层：业务处理层

-dao层：Spring的jdbcTemplate

1.2 Spring的入门

1、把对象的创建交给Spring进行管理

2、 IOC的操作实现有两种方式（xml配置文件和注解方式）

1.2.1 IOC底层原理

l xml配置文件

l dom4j解析xml

l 工厂设计模式

l 反射

1.2.2 IOC入门案例

第一步导入jar包

做spring基本功能，只需导入以下三个jar包

第二步创建类，在类里面创建方法

第三步创建Spring配置文件，配置创建类

（1） Spring核心配置文件名称和位置不是固定的

建议放到src下面，官方建议名称applicationContext.xml

（2）引入schema约束

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

</beans>

（3）配置对象创建

第四步写代码测试对象

1.2.3 别名

<beans>

</beans>

通过这样的配置，可以达到在一个地方命名，在多个地方使用不同的名字的效果。

1.2.4 解决配置文件没有提示

1. Spring引入schema约束,把约束文件引入到myeclipse中

-复制约束文件路径

2. 其他标签没有提示也是参考这个操作方法（例如：context，aop，tx 等）

1.3 Spring的bean管理（xml配置文件）

1.3.1 bean实例化三种方式

第一种使用类的无参数构造创建对象(重点)

类里面没有无参的构造方法，会出现异常

第二种使用静态工厂创建

（1）创建静态方法，返回类对象

第三种使用实例化工厂

（1）创建不是静态方法，返回类对象

1.3.2 初始化bean时机

Spring默认在启动时将所有singleton bean提前进行实例化。提前实例化意味着作为初始化的一部分，ApplicationContext会自动创建并配置所有的singleton bean.通常情况下这是件好事。因为这样在配置中有任何错误能立即发现。

Lazy-init=”true or false”

Lazy-init 为false,spring容器将在启动的时候报错（比较好的一种方式）

Lazy-init 为true,spring容器将在调用该类的时候出错。

默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。如：

如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下：

1.3.3 init、destroy

Spring初始化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法。

<bean id=“foo” class=“...Foo”

init-method=“setup” 当bean被载入到容器的时候调用setup

destory-method=“teardown”/> 当bean从容器中删除的时候调用teardown(scope= singleton有效)，web容器中会自动调用，但是main函数或测试用例需要手动调用

Bean生命周期：

1. instantiate bean对象实例化

2. populate properties 封装属性

3. 如果Bean实现BeanNameAware 执行 setBeanName

4. 如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setApplicationContext

5. 如果存在类实现 BeanPostProcessor（后处理Bean），执行postProcessBeforeInitialization

6. 如果Bean实现InitializingBean 执行 afterPropertiesSet

7. 调用<bean init-method="init"> 指定初始化方法 init

8. 如果存在类实现 BeanPostProcessor（处理Bean），执行postProcessAfterInitialization

9. 执行业务处理

如果Bean实现 DisposableBean 执行 destroy

10. 调用<bean destroy-method="customerDestroy"> 指定销毁方法 customerDestroy

1.3.4 bean标签常用属性

（1） id属性：id属性名称任意命名，不能包含特殊字符，id属性不是必须的，但是是唯一的。

（2） class属性：创建对象所在类的全路径

（3） name属性：功能和id属性一样，id属性不能包含特殊字符，但是在name里面可以包含特殊字符。

（4） scope属性：

-singleton ：默认值单例

-prototype ：多例

-request：创建对象把对象放到request域里面

-session：创建对象把对象放到session域里面

-globalSession：创建对象把对象放到globalSession域里面

（5） autowire属性：byName就是通过Bean的id或者name，byType就是按Bean的Class的类型

1.3.5 依赖注入介绍

1. 依赖注入就是创建对象的时候，向类的属性里面设置值

2. 依赖注入的方式有三种

第一种使用set方法注入（重点）

public class User{

private String name;

public void setName(String name){

This.name = name;

}

User user = new User();

User.setName(“abc”);

第二种有参数构造注入

public class User{

private String name;

public User(String name){

This.name = name;

}

User user = new User(“姗姗”);

第三种使用接口注入（Spring框架不支持）

public interface Dao{

public void save(String name);

}

public class DaoImpl implements Dao{

private String name

public void save(string name){

this.name = name;

}

1.3.6 依赖注入操作

1.3.6.1 使用有参构造注入

-index：通过参数顺序

-type：通过参数类型

-name：通过参数名称（3.0以后版本支持）

1.3.6.2 使用set方法注入

1.3.7 Spring注入对象类型属性（重点）

1. 创建UserService类和UserDao类

（1）要在UserService里面得到UserDao层的对象

2. 具体实现过程

（1）在UserService里面把UserDao作为类型属性

（2）生成UserDao类型属性的set方法

（3）配置文件中的对应关系

1.3.8 Spring注入复杂数据

1. 数组，List集合，Map集合，Properties

<list>

</list>

</property>

<list>

<value>xiaoxi</value>

</list>

</property>

<map>

</map>

</property>

<props>

</props>

</property>

</bean>

1.3.9 P名称空间注入

1.4 IOC和DI区别

（1） IOC：控制反转，把对象创建交给Spring进行配置

（2） DI：依赖注入，向类里面的属性设置值

（3）关系：依赖注入不能单独存在，需要在IOC基础之上完成操作

1.5 Spring整合web项目原理

1. 加载Spring核心配置文件

（1） new对象，功能可以实现，效率很低

2. 实现思想：把加载配置文件和创建对象过程，在服务器启动的时候完成

3. 实现原理

（1）ServletContext对象

（2）监听器

（3）具体使用：

-在服务器启动时候，为每个项目创建一个ServletContext对象

-在ServletContext对象创建时候，使用监听器可以具体到ServletContext对象在什么时候创建

-使用监听器听到ServletContext对象创建时候

-加载Spring配置文件，按照配置文件内容创建对象

-把创建出来的对象放到ServletContext对象域里面（setAttribute()方法）

-获取对象时候，到ServletContext对象域里面取（getAttribute()方法）