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">

<!-- <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.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 id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/>

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

<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

<!--注入复杂类型属性值  -->

<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.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()方法）