SSM----Spring

Spring

1.什么是Spring?
Spring是一个开源的分层的javaSE/javaEE一站式的容器的轻量级的，解决业务逻辑层【Service】与web层和数据访问层之间的松耦合问题。
(1)开源的
(2)javaSE/javaEE一站式
(3)容器框架
(4)轻量级
(5)解决业务逻辑层【Service】与web层和数据访问层之间的松耦合

2.Spring的结构组成

从下往上test，core容器，aop【面向切面编程】，web，data access
1.test部分只有一个模块：
spring-test：spring测试，提供junit与mock测试功能
spring-context-support：spring额外支持包，比如邮件服务、视图解析等
它们的依赖关系

2.core部分包含4个模块
spring-core：依赖注入IoC与DI的最基本实现
spring-beans：Bean工厂与bean的装配
spring-context：spring的context上下文即IoC容器
spring-expression：spring表达式语言
它们的完整依赖关系

3.aop部分包含4个模块
spring-aop：面向切面编程
spring-aspects：集成AspectJ
spring-instrument：提供一些类级的工具支持和ClassLoader级的实现，用于服务器spring-instrument-tomcat：针对tomcat的instrument实现
它们的依赖关系

4.web部分包含4个模块
spring-web：基础web功能，如文件上传
spring-webmvc：mvc实现
spring-webmvc-portlet：基于portlet的mvc实现
spring-struts：与struts的集成，不推荐，spring4不再提供
它们的依赖关系

5.data access部分包含5个模块
spring-jdbc：jdbc的支持
spring-tx：事务控制
spring-orm：对象关系映射，集成orm框架
spring-oxm：对象xml映射
spring-jms：java消息服务
它们的依赖关系

3.Spring的优点
Spring的出现解决了JavaEE实际问题：
1.方便解耦，简化开发：Spring是一个超级工厂（超级容器），可以将对象的创建和依赖关系交给Spring工厂去管理
2.AOP编程：Spring提供面向切面编程，可以方便的对程序进行运行监控、权限验证等操作
3.声明事务：只需要通过配置就可以完成对事务的管理，不需要手动编程
4.方便测试：Spring支持junit4，可以通过Spring注解方式测试程序
5.方便集成各种框架：Spring支持各种开源框架的集成。例如（struts、Hibernate、MyBaties等）
6.降低JavaEE API的使用难度： Spring对JavaEE开发中非常难用的API进行封装，使这些开发API应用难度降低。

4.Spring的核心技术
1.IoC（Inverse of Control 反转控制）：将java对象创建和维护权利交由Spring工厂进行管理和维护。
2.DI(依赖注入)：将某一个java类中的依赖对象快速的添加到另一个java类中。
3.AOP（Aspect Oriented Programming 面向切面编程），基于动态代理的功能增强方式[给自己的程序中添加一些系统需求的处理【日志管理，数据的安全性检查…】]。
4.事务管理的相关操作。
5.Spring整合/管理其他各层的框架【Spring集成web层SpringMVC/Spring整合数据访问层MyBatis】{SSM}

5.Spring的IoC（Inverse of Control 反转控制）
IoC（Inverse of Control 反转控制）： 将java对象创建和维护权利交由Spring工厂进行管理和维护。

例如：
package com.click369.javabean;

public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;
    
    public StudentBean(){
   }
    
    public StudentBean(int stuid,String stuname,int stuage){
   
    	this.stuid=stuid;
    	this.stuname=stuname;
    	this.stuage=stuage;
    }
    
	public int getStuid() {
   
		return stuid;
	}
	public void setStuid(int stuid) {
   
		this.stuid = stuid;
	}
	public String getStuname() {
   
		return stuname;
	}
	public void setStuname(String stuname) {
   
		this.stuname = stuname;
	}
	public int getStuage() {
   
		return stuage;
	}
	public void setStuage(int stuage) {
   
		this.stuage = stuage;
	}
	@Override
	public String toString() {
   
		return "stuid=="+stuid+"  stuname=="+stuname+" stuage=="+stuage;
	}
}
/**
	 * 在没有使用Spring的时候，我们要想创建java对象，就得自己new
	 */
	@Test
	public  void test1(){
   
		//自己new的java对象，java对象的创建是程序开发者自己创建维护
		StudentBean stu=new StudentBean(1001,"zhangsan",23);
		System.out.println(stu.toString());
		
	}

6.Bean实例化4种方式
1.1无参数构造方法（开发最常用）

package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;
    
public StudentBean(){
   }
.............
}

编写Spring的配置文件：【applicationContext.xml/自己起名】{
   src/main/resources}
<!-- 无参数构造方法实例化bean -->
<!-- id:对象名称 -->
<!-- class:被创建对象的java类的包名+类名 -->
<bean id="stu" class="com.click369.javabean.StudentBean"></bean>

1.2静态工厂方法实例化bean
静态工厂方法：在一个类中书写静态的方法，这个方法返回某个Bean的对象（在方法中创建Bean的对象）。

实体类：
package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;
    
public StudentBean(){
   }
.............
}
创建一个静态工厂方法类，提供一个静态方法，让这个静态方法返回一个实体类的对象
package com.click369.javabean;
/**
 * 静态工厂方法类
 * @author Administrator
 *
 */
public class StaticFactoryMethodClass {
   
	/**
	 * 静态方法，让这个静态方法返回一个实体类的对象
	 * @return
	 */
	public  static  StudentBean   getStaticStudentBean(){
   
		return new StudentBean();
	}
}

编写Spring配置
<!-- 静态工厂方法实例化bean的配置 -->
	<!-- id:对象名称 -->
	<!-- factory-method:配置静态工厂方法 -->
	<!-- class:配置静态工厂方法类【包名+类名】 -->
	<bean id="student" factory-method="getStaticStudentBean" class="com.click369.javabean.StaticFactoryMethodClass"></bean>

1.3实例工厂方法实例化bean

实体类：
package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;
    
public StudentBean(){
   }
.............
}

创建一个工厂类，提供实例方法，这个实例方法返回java实体类的对象
package com.click369.javabean;

/**
 * 工厂类
 * @author Administrator
 *
 */
public class StudentFactory {
   
    /**
     * 实例方法，返回实体类对象
     * @return
     */
	public  StudentBean getStudentBean(){
   
		return new StudentBean();
	}
}
Spring配置文件的编写：
<!-- 实例工程方法实例化bean的配置 -->
	<!-- 创建实例工厂类对象 -->
	<bean id="studentFactory" class="com.click369.javabean.StudentFactory"></bean>
	<!-- 配置得到实体类对象 -->
	<!-- id:对象名称 -->
	<!-- factory-bean:实例工厂类对象 -->
	<!-- factory-method:实例工厂类中创建实体类的方法 -->
	<bean id="student" factory-bean="studentFactory" factory-method="getStudentBean"></bean>

1.4FactoryBean接口方式实例化bean
FactoryBean是Spring提供的接口，专门用于对bean进行初始化操作的。
如果bean需要使用这种方式进行初始化，那么需要定义类实现这个FactoryBean接口，在实现类中复写getObject的方法。

实体类：
package com.click369.javabean;
public class StudentBean {
   
    private  int stuid;
    private  String  stuname;
    private  int stuage;
    
public StudentBean(){
   }
.............
}
创建一个类，实现FactoryBean接口，重写getObject的方法，返回实体类对象。
package com.click369.factory;
import org.springframework.beans.factory.FactoryBean;
import com.click369.javabean.StudentBean;
public class CreateObject implements FactoryBean<StudentBean>{
   
	@Override
	public StudentBean getObject() throws Exception {
   
		return new StudentBean();
	}
	@Override
	public Class<?> getObjectType() {
   
		return StudentBean.class;
	}
}
Spring配置文件：
<!-- FactoryBean实例化Bean的配置 -->
	<!-- id:对象名称 -->
	<!-- class:实现FactoryBean接口的java类的包名+类名 -->
	<bean id="student" class="com.click369.factory.CreateObject"></bean> 

7.FactoryBean接口与BeanFactory接口的区别
共同点：都是接口。
不同点：FactoryBean是Spring提供的专门用来实例化java类的接口。【创造】
BeanFactory接口表示一个Spring工厂对象【Spring容器对象】，包含了实例化好的java类对象。【管理】

8.bean的作用域
bean的作用域：主要是指Spring创建的Bean对象是单例、多例、request、session级别。
有点像JSP动作元素useBean的page/request/session/application.

singleton: 单例模式【在一个spring容器中，对象只有一个实例。（默认值）】
prototype：多例模式/原型模式【在一个spring容器中，存在多个实例，每次getBean 返回一个新的实例。】
request：该属性仅对HTTP请求产生作用，使用该属性定义Bean时，每次HTTP请求都会创建一个新的Bean，适用于WebApplicationContext环境。【一次请求一个对象】
session：该属性仅用于HTTP Session，同一个Session共享一个Bean实例。不同Session使用不同的实例。【同一次回话中的对象都是相同的】
global session：该属性仅用于HTTP Session，同session作用域不同的是，所有的Session共享一个Bean实例。【多个session共享一个对象】
下面重点讨论singleton、prototyp作用域，request,session和global-session类作用域放到Spring MVC章节讨论，这里不再做详细讲述。

通过在配置Spring配置文件是设置bean元素的scope属性设置bean的作用域：
bean元素的scope属性：singleton，prototype，request，session，global session。

9.bean的生命周期
Spring工厂对象【Spring容器对象】负责创建对象，初始化对象，销毁对象。
也就是说任何一个交给Spring的Bean，它的生命周期统一由Spring容器维护。

10.Spring的依赖注入是什么？实现方式有几种？每一种如何操作？
DI–依赖注入，建立在IoC[控制反转]基础之上的，没有控制反转就谈不上依赖注入。
依赖注入–在调用者类中将被调用者类的对象，添加到调用者类中这个过程就是依赖注入。 在这个过程中被调用者类的对象就是调用者类的依赖对象。
把Service添加到Servlet中的过程叫依赖注入

1.构造方法注入

创建被调用者类
package com.click369.javabean;
/**
 * 被调用者类
 * @author Administrator
 *
 */
public class PersonBean {
   

	 public  PersonBean(){
   
		 System.out.println("PersonBean--被调用者类的构造方法");
	 }
	 
	 public void testPerson(){
   
		 System.out.println("测试被调用者类");
	 }
}

调用者类
package com.click369.javabean;
/**
 * 调用者类
 * @author Administrator
 *
 */
public class StudentBean {
   
	//依赖对象
	public  PersonBean   personBean;
	
    public StudentBean(PersonBean   personBean){
   
    	System.out.println("StudentBean--调用者类的构造方法");
    	this.personBean=personBean;
}

    public  void  testStudent(){
   
    	System.out.println("测试StudentBean类");
    	personBean.testPerson();
    }
}
Spring配置文件
<!-- 创建被调用者类PersonBean -->
<bean id="person" class="com.click369.javabean.PersonBean"></bean>
<!-- 创建调用者类StudentBean -->
<bean id="student" class="com.click369.javabean.StudentBean">
	    <!-- 构造方法注入 -->
	    <!-- index:构造方法参数的索引值 -->
	    <!-- ref:引用对象 -->
	    <constructor-arg index="0" ref="person"></constructor-arg>