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 Spring概念

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

(1) Spring核心两部分:IOCAOP

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

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

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

 

(2) Spring是一站式框架

SpringJavaEE三层结构中,每一层都提供不同的解决技术

-Web层:Springmvc

-Webservice层:业务处理层

-dao层:SpringjdbcTemplate

 

1.2 Spring的入门

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

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

1.2.1 IOC底层原理

xml配置文件

dom4j解析xml

工厂设计模式

反射

 

 

 

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. 其他标签没有提示也是参考这个操作方法(例如:contextaoptx 等)

1.3 Springbean管理(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 initdestroy

      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就是通过Beanid或者namebyType就是按BeanClass的类型

 

 

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 IOCDI区别

(1) IOC:控制反转,把对象创建交给Spring进行配置

(2) DI:依赖注入,向类里面的属性设置值

(3) 关系:依赖注入不能单独存在,需要在IOC基础之上完成操作

1.5 Spring整合web项目原理

1. 加载Spring核心配置文件

 

(1) new对象,功能可以实现,效率很低

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

3. 实现原理

1ServletContext对象

2)监听器

3)具体使用:

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

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

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

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

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

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

posted @ 2019-03-06 09:35  lilixia  阅读(229)  评论(0编辑  收藏  举报