奥门永利误乐域:Spring笔记

spring01,

一、spring介绍

1、spring的概念、特点

  概念:

  spring是一个分层的开源的轻量级框架,实际上是一个存放对象的容器,核心是控制反转(IoC)、面向切面(AOP),项目中所有对象的创建和依赖关系的维护都交给spring来管理,不用再自己创建和维护;

  特点(优势):

    奥门永利误乐域 1

2、准备工作:

  导入jar包:

    奥门永利误乐域 2

  导入约束:

   奥门永利误乐域 3

3、注册对象到容器中(举例)

4、IoC思想(控制反转):涉及到DI(依赖注入技术)和IoC思想,IOC思想的实现要依赖于DI技术;控制反转指的是,对象的创建和管理交给spring而不是开发者手动创建;

  奥门永利误乐域 4

5、两个接口的对比

  BeanFactory接口(顶层接口,其实现类的功能单一,已过时,在资源匮乏的时候会使用,因为他只有在每次获得对象的时候才创建对象);

  ApplicationContext接口(继承于BeanFactory接口,实现类的功能较多,特点是:每次容器启动时,就会创建容器中配置的所有对象,获取对象时,直接在里边取即可);

6、spring简单配置

  (1)Bean元素(配置文件xml的根元素)的配置:将对象交给spring来管理,用Bean元素来描述需要spring管理的那些对象,如下图:

    奥门永利误乐域 5

    然后,比如在测试类里需要获取对象时,可以:

    奥门永利误乐域 6

7、spring创建对象的三种方式

  (1)空参构造方式:上述6里边的图片,创建一个User类,在xml里配置name,class属性后,通过User的空参构造方法来创建对象user;

  (2)静态工厂方式:首先创建一个UserFactory(工厂类),类里边定义一个静态的方法(因此叫静态工厂方式),获得User的对象user:

    奥门永利误乐域 7

  (3)动态实例化方式:将上述UserFactory(工厂类)里的静态方法换为非静态的方法,这时候,xml里的配置有些变化:如下是(2)(3)两种方式的不同配置方式:

    
 可以看到,(3)中由于工厂方法是非静态的,所以配置的时候需要先配置,创建UserFactory的实例化对象,再用该对象调用createUser2()方法,获取user对象;

      其中多了一个factory-bean属性,切记;

    奥门永利误乐域 8

    结论:(1)用得最多,(2)(3)基本不用,了解即可;

二、spring配置详解(进阶)

  说明:除了一中简单的bean配置,下面介绍详细的spring配置:

  1、<bean></bean>里边的scope属性;

   常见的四种属性值:(重点是前两种)

   (1)singleton(单例),这是默认的,不写的话,默认创建的是单例对象;

      User  u1 =  ac.getBean(“user”);

      User  u2 =
 ac.getBean(“user”);,这里u1和u2是同一个对象,打印(u1==u2)时返回true;并且只调用了一次空参构造方法; 

   (2)prototype(多例),每次创建时都会调用一次空参构造,且每次创建的都是不同对象;

   (3)request:web环境下,对象与request生命周期一致;(了解,即使在web环境下也基本不用);

   (4)session:web环境下,对象与session生命周期一致;(了解,即使在web环境下也基本不用);

  结论:(1)(2)比较常用,以后开发中大部分使用(1)单例模式;(2)在struts2中使用,在struts2中,根据struts2架构的设计,action对象每次获取时必须是一个新的对象交给spring来管理,所以action必须设置为prototype(多例)。

  2、初始化&销毁方法(即生命周期方法)

  在bean里配置两个方法:<bean  init-method=”init”
 destroy-method=”destroy”></bean>,然后还要在User类里边定义这两个方法,注意名字要与init/destroy一致,这样的话,每次创建完对象之后(空参构造调用之后),就会执行init的方法,但是要想调用到destroy方法,必须在测试方法里获取完对象之后,添加:ac.close();

  3、模块化配置

    在spring配置文件中引入其他配置文件,不需要将所有配置写在一个文件中;

    奥门永利误乐域 9

  4、spring属性注入(4种)

奥门永利误乐域,  (1)set方法注入(带头大哥级别,最简单,最重要的):这种方法要求User类里边必须有set方法;

    注:User类里边如果有对象属性(如下面的User类里的car对象),普通的属性值用value,对象属性的值(引用)用ref;

      即先把car对象配置在容器中,然后再user里用ref引用;

    class  User{

      private  String  name;

      private  int  age;

      private  Car  car;//这里就是car对象,当然,也要创建Car类

    } 

1 <!-- set方式注入: -->
2     <bean  name="user" class="cn.itcast.bean.User" >
3         <!--值类型注入: 为User对象中名为name的属性注入tom作为值 -->
4         <property name="name" value="tom" ></property>
5         <property name="age"  value="18" ></property>
6         <!-- 引用类型注入: 为car属性注入下方配置的car对象 -->
7         <property name="car"  ref="car" ></property>
8     </bean>

  <!– 将car对象配置到容器中 –>
    <bean name=”car” class=”cn.itcast.bean.Car” >
      <property name=”name” value=”兰博基尼”
></property>
      <property name=”color” value=”黄色”
></property>
    </bean>

  (2)构造函数注入

 1     <!-- 构造函数注入 -->
 2 <bean name="user2" class="cn.itcast.bean.User" >
 3     <!-- name属性: 构造函数的参数名 -->
 4     <!-- index属性: 构造函数的参数索引 -->
 5     <!-- type属性: 构造函数的参数类型-->
 6     <constructor-arg name="name" index="0" type="java.lang.Integer" value="999"  ></constructor-arg>
 7     <constructor-arg name="car" ref="car" index="1" ></constructor-arg>
 8 </bean>
 9 
10 
11         注:index是为了区分当Bean类有多个构造函数时,按索引走哪个构造函数;
12            type是为了区分多个构造函数,但是函数参数类型不同时,根据type来确定走哪个构造函数;

  (3)p名称空间注入(spring新研发的)

1 <!-- p名称空间注入, 走set方法
2     1.导入P名称空间  xmlns:p="http://www.springframework.org/schema/p" (也可以在Namespaces里设置)
3     2.使用p:属性完成注入
4         |-值类型: p:属性名="值"
5         |-对象类型: p:属性名-ref="bean名称"
6  -->
7     <bean  name="user3" class="cn.itcast.bean.User" p:name="jack" p:age="20" p:car-ref="car"  >
8     </bean>

  (4)spel注入(spring  Expression  Language , spring EL表达式)

    注意下面代码中的绿色文字;

1 <!-- 
2     spel注入: spring Expression Language sping表达式语言
3  -->
4 <bean  name="user4" class="cn.itcast.bean.User" >
5         <property name="name" value="#{user.name}" ></property>//固定格式#{},可以取user的name
6         <property name="age" value="#{user3.age}" ></property>//取user3对象的age
7         <property name="car" ref="car" ></property>
8 </bean>//注:对象属性的引入,不能使用spel的方法!!!

  (5)复杂类型注入(数组、集合、map、Properties类型属性的注入)

  比如:

    奥门永利误乐域 10

  下边分别介绍:

 1 <bean name="cb" class="cn.itcast.c_injection.CollectionBean" >
 2     <!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 
 3     <property name="arr" value="tom" ></property>
 4     -->
 5     <!-- array注入,多个元素注入 -->
 6     <property name="arr">
 7         <array>
 8             <value>tom</value>
 9             <value>jerry</value>
10             <ref bean="user4" />
11         </array>
12     </property>
13 -----------------------------------------------------------------------------    
14     <!-- 如果List中只准备注入一个值(对象),直接使用value|ref即可        
15     <property name="list" value="jack" ></property>-->
16         <!--list注入,多个元素注入-->
17     <property name="list"  >
18         <list>
19             <value>jack</value>
20             <value>rose</value>
21             <ref bean="user3" />
22         </list>
23     </property>
24 -----------------------------------------------------------------------------
25     <!-- map类型注入 -->
26     <property name="map"  >
27         <map>
28             <entry key="url" value="jdbc:mysql:///crm" ></entry>
29             <entry key="user" value-ref="user4"  ></entry>
30             <entry key-ref="user3" value-ref="user2"  ></entry>
31         </map> 
32     </property>
33 -----------------------------------------------------------------------------
34     <!-- prperties 类型注入 -->
35     <property name="prop"  >
36         <props>
37             <prop key="driverClass">com.jdbc.mysql.Driver</prop>
38             <prop key="userName">root</prop>
39             <prop key="password">1234</prop>
40         </props>
41     </property>
42 </bean>

 

http://www.bkjia.com/Javabc/1305476.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1305476.htmlTechArticlespring01, 一、spring介绍 1、spring的概念、特点
概念:
spring是一个分层的开源的轻量级框架,实际上是一个存放对象的容器,核心是控制反转…

一、 Spring技术概述
1、什么是Spring : Spring是分层的JavaSE/EE full-stack(一站式)
轻量级开源框架
* JavaEE 程序在服务器端被分为三层
(Web层【表现层】、业务逻辑层、数据访问层【集成层、持久层】)
* struts2 是表现层MVC的框架
* hibernate 是数据访问层(持久层)的完全ORM框架

Spring框架中包括JavaEE 三层的 每一层的解决方案 (一站式)
* web层 SpringMVC
* 业务层 Spring Bean管理、AOP、事务管理
* 持久层 Spring JDBCTemplate、 ORM模块(整合其他持久层框架)

2、 Spring的核心 : IoC 控制反转 和 Aop 面向切面编程

  • 课程以3.2 版本讲解

3、 Spring的由来 : 作者 Rod Johnson
2002年 Expert One-to-One J2EE Design and Development (分析J2EE开发
使用技术 EJB)
2004年 Expert One-to-One J2EE Development without EJB
(客观分析J2EE开发需要什么,推出一个新的框架, 后来Spring)

sun 公司在最早J2EE规范中,提供业务层解决方案 EJB

Spring出现就是为了解决JavaEE开发实际问题,轻量级,
相比EJB比较繁重、复杂的解决方案

4、 Spring 框架优点

  • 方便解耦,简化开发
    Spring就是一个大工厂,可以将所有对象创建和依赖关系维护,交给Spring管理
  • AOP编程的支持
    Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能
  • 声明式事务的支持
    只需要通过配置就可以完成对事务的管理,而无需手动编程
  • 方便程序的测试
    Spring对Junit4支持,可以通过注解方便的测试Spring程序
  • 方便集成各种优秀框架
    Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持
  • 降低JavaEE API的使用难度
    Spring
    对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低

5、Spring 包括哪些东西?

  • 核心技术 IoC 和 AOP
  • 数据访问 (持久层解决方案)
  • Web层解决方案 SpringMVC
  • 集成 (整合其他开源框架)

未来五天课程: IoC 、 AOP 、 数据访问、 集成

========================================================================================================================
二、 Spring 控制反转案例快速入门
1、下载Spring最新开发包
http://www.springsource.org/download/community
下载spring3.2 的开发包
目录结构
* docs 存放API和 规范文档
* libs 开发jar包
* schemas 开发过程中需要导入xml的schema 约束

2、复制Spring开发 jar包到工程
复制核心容器包含jar包 (beans、core、context、expression language)
spring 的 jar包 需要依赖 commons-logging的 jar (commons-logging 类似
slf4j 是通用日志组件,需要整合 log4j )

  • 提示:spring3.0.X 版本 asm jar包 已经被合并到 spring core包中

3、理解IoC控制反转和DI依赖注入
IoC Inverse of Control
反转控制的概念,就是将原本在程序中手动创建HelloService对象的控制权,交由Spring框架管理,简单说,就是创建HelloService对象控制权被反转到了Spring框架

DI:Dependency Injection
依赖注入,在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件

面试题: IoC 和 DI的区别?
IoC 控制反转,指将对象的创建权,反转到Spring容器 , DI
依赖注入,指Spring创建对象的过程中,将对象依赖属性通过配置进行注入

4、编写Spring核心配置文件
在src目录创建 applicationContext.xml
在 docs\spring-framework-reference\html 找到 xsd-config.html

5、在程序中读取Spring配置文件,通过Spring框架获得Bean,完成相应操作
加载classpath (src):
new ClassPathXmlApplicationContext(“applicationContext.xml”);
加载磁盘路径:
new FileSystemXmlApplicationContext(“applicationContext.xml”);
创建Spring 核心工厂对象

通过工厂的getBean 获得配置实例对象 (IHelloService)
applicationContext.getBean(“helloService”);

三、 Spring 工厂接口
BeanFactory 接口 和 ApplicationContext 接口区别 ?
* ApplicationContext 接口时 继承 BeanFactory 接口 ,Spring
核心工厂是BeanFactory ,BeanFactory
采取延迟加载,第一次getBean时才会初始化Bean , ApplicationContext
是会在加载配置文件时 初始化Bean
* ApplicationContext是对BeanFactory扩展
国际化处理
事件传递
Bean自动装配
各种不同应用层的Context实现

开发中基本都在使用ApplicationContext, web项目使用WebApplicationContext
,很少用到BeanFactory
BeanFactory beanFactory = new XmlBeanFactory(new
ClassPathResource(“applicationContext.xml”));
IHelloService helloService = (IHelloService)
beanFactory.getBean(“helloService”);
helloService.sayHello();

四、 在MyEclipse 配置Spring的xml文件提示
xml需要导入schema约束,约束指向网络路径
1、 联网后,自动缓存路径文件到本地,提供提示功能
2、 无法联网 ,需要配置 xsd schema文件位置
到解压spring/schemas/beans/spring-beans-3.2.xsd
选择schema location 方式
复制网络路径
http://www.springframework.org/schema/beans/spring-beans.xsd

=========================================================================================================================
五、 IoC容器装配Bean(xml配置方式)
1、 Spring 提供配置Bean 三种实例化方式
1)使用类构造器实例化(默认无参数)
<bean id=”bean1″
class=”cn.itcast.spring.b_instance.Bean1″></bean>
2)使用静态工厂方法实例化(简单工厂模式)
<bean id=”bean2″ class=”cn.itcast.spring.b_instance.Bean2Factory”
factory-method=”getBean2″></bean>
3)使用实例工厂方法实例化(工厂方法模式)
<bean id=”bean3Factory”
class=”cn.itcast.spring.b_instance.Bean3Factory”></bean>
<bean id=”bean3″ factory-bean=”bean3Factory”
factory-method=”getBean3″></bean>

2、 Bean的其它属性配置
<bean>元素的id属性 和 name属性的区别
早期Spring开发中 Bean的 id属性 ,遵守xml语法 id约束
* id 的命名要满足XML对ID属性命名规范
必须以字母开始,可以使用字母、数字、连字符、下划线、句话、冒号
使用name属性,就可以使用很多特殊字符 , 早期在struts1 和 spring整合
<bean name=”/login” class=”….LoginAction” /> name中含有/
,使用id会报错

****** 如果元素没有id只有name ,name 属性值可以作为id 使用

<bean>元素scope属性
    * scope="singleton" 单例 ,在Spring IoC容器中仅存在一个Bean实例 (默认的scope)
    * scope="prototype" 多例 ,每次从容器中调用Bean时,都返回一个新的实例,即每次调用getBean()时 ,相当于执行new XxxBean()
    * scope="request" 用于web开发,将Bean放入request范围 ,request.setAttribute("xxx") , 在同一个request 获得同一个Bean
    * scope="session" 用于web开发,将Bean 放入Session范围,在同一个Session 获得同一个Bean
    * scope="globalSession" 一般用于Porlet应用环境 , 分布式系统存在全局session概念 ,如果不是porlet环境,globalSession 等同于Session
在开发中主要使用 scope="singleton"、 scope="prototype"

3、 Bean的生命周期
在配置 <bean> 元素,通过 init-method 指定Bean的初始化方法,通过
destroy-method 指定Bean销毁方法
* destroy-method 只对 scope=”singleton” 有效
* 销毁方法,必须关闭ApplicationContext对象,才会被调用
ClassPathXmlApplicationContext applicationContext = new
ClassPathXmlApplicationContext(“applicationContext.xml”);
applicationContext.close();

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、执行业务处理
10、如果Bean实现 DisposableBean 执行 destroy
11、调用<bean destroy-method=”customerDestroy”> 指定销毁方法
customerDestroy

第三步和第四步,使Bean 了解Spring容器
第五步和第八步,使用BeanPostProcessor
就是钩子函数,作用用来对Bean对象进行扩展

问题: 在userDAO对象所有方法上 添加运行时间监控
解决: 使用 BeanPostProcessor 完成

==========================================================================================================================
4、Spring的Bean属性的依赖注入
支持 构造器注入 和 setter 方法注入

第一种 构造器注入 ,通过 <constructor-arg> 元素完成注入
<bean id=”car” class=”cn.itcast.spring.e_di.Car”>

<constructor-arg index=”0″ type=”java.lang.String”
value=”保时捷”></constructor-arg>
<constructor-arg index=”1″ type=”double”
value=”1000000″></constructor-arg>
</bean>

发表评论

电子邮件地址不会被公开。 必填项已用*标注