Java三大框架之Spring

Spring 的概述:

• 什么是 Spring
  Spring 是一个开源框架，Spring 是于2003 年兴起的一个轻量级的Java 开发框架，由 RodJohnson
  在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。它是
  为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使
  用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring 使用基本的 JavaBean
  来完成以前只可能由 EJB 完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、
  可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转
  （IoC）和面向切面（AOP）。简单来说，Spring 是一个分层的 JavaSE/EEfull-stack(一站式) 轻量级
  开源框架。

  EE 开发分成三层结构
  * WEB 层:Spring MVC.
  * 业务层:Bean 管理:(IOC)
  * 持久层:Spring 的 JDBC 模板.ORM 模板用于整合其他的持久层框架.

为什么学习 Spring

方便解耦，简化开发

• Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理 AOP 编程的支持

• Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 声明式事务的支持

• 只需要通过配置就可以完成对事务的管理，而无需手动编程 方便程序的测试

• Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序 方便集成各种优秀框架

• Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、 MyBatis、Quartz
  等）的直接支持

• 降低 JavaEE API 的使用难度

• Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等），都提供了封装， 使这些 API应用难度大大降低

Spring 的版本

• Spring 3.X 和 Spring4.X

Spring 的入门案例:(IOC)

IOC 的底层实现原理(工厂+反射+配置文件)

IOC：Inversion of Control 控制反转. 指的是 对象的创建权反转(交给)给 Spring.
作用是实现了程序的解耦合.

步骤一:下载 Spring 的开发包

官网：官网地址
下载地址：下载地址
解压:(Spring目录结构:)

docs ：API和开发规范.
libs ：jar包和源码.
schema ：约束.

步骤二:创建 web 项目,引入 Spring 的开发包

步骤三:引入相关配置文件

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	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-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
</beans>

log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

log4j.rootLogger=error, stdout

log4j.logger.com.springframework=DEBUG
log4j.logger.com.ibatis=DEBUG  
log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=DEBUG  
log4j.logger.com.ibatis.common.jdbc.ScriptRunner=DEBUG  
log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG  

log4j.logger.java.sql.Connection=DEBUG  
log4j.logger.java.sql.Statement=DEBUG  
log4j.logger.java.sql.PreparedStatement=DEBUG  
log4j.logger.java.sql.ResultSet=DEBUG

步骤四:编写相关的类

public interface UserDao{
	public void sayHello();
}

public class UserDaoImpl implements UserDao {
	@Override
	public void sayHello() {
		System.out.println("Hello Spring...");
	}
}

步骤五:完成配置

	<!-- Spring的入门案例================ -->
	<bean id="userDao" class="cn.test.spring.demo1.UserDaoImpl"></bean>

步骤六:编写测试程序

@Test
// Spring的方式：
public void demo2(){
	// 创建 Spring的工厂类：
	ApplicationContext applicationContext=
		new ClassPathXmlApplicationContext("applicationContext.xml");
	// 通过工厂解析 XML获取 Bean的实例.
	UserDao userDao = (UserDao) applicationContext.getBean("userDao");
	userDao.sayHello();
}

IOC 和 DI

• IOC :控制反转,将对象的创建权交给了 Spring.
• DI :Dependency Injection 依赖注入.需要有 IOC 的环境,Spring 创建这个类的过程中,Spring 将类的依 赖的属性设置进去.

Spring 中的工厂(容器)

1. ApplicationContext
   ApplicatioContext接口有两个实现类:
   ClassPathXmlApplicationContext :加载类路径下 Spring的配置文件.
   FileSystemXmlApplicationContext :加载本地磁盘下 Spring的配置文件.
   
2. BeanFactory(过时)
   
3. BeanFactory 和 ApplicationContext 的区别:
   BeanFactory :是在 getBean的时候才会生成类的实例.（在硬件比较差的地方使用）
   ApplicationContext :在加载 applicationContext.xml(容器启动)时候就会创建.

配置 STS 的 XML 的提示

1. Spring 配置文件中提示的配置
   复制路径:http://www.springframework.org/schema/beans/spring-beans.xsd
   查找 XML Catalog:
   
   点击 Add…

Spring 的相关配置

1. id 属性和 name 属性标签的配置
   id :Bean起个名字. 在约束中采用 ID的约束:唯一.必须以字母开始，可以使用字母、数字、连字符、
   下划线、句话、冒号 id:不能出现特殊字符.
   
   name:Bean起个名字. 没有采用 ID的约束. name:出现特殊字符.如果没有 id的话 , name 可
   以当做 id使用.
   整合 struts1的时候:
   

2. scope 属性：Bean 的作用范围

   • singleton :默认值，单例的.
   • prototype :多例的.
   • request :WEB项目中,Spring创建一个 Bean的对象,将对象存入到 request域中.
   • session :WEB项目中,Spring创建一个 Bean的对象,将对象存入到 session域中.

globalSession:WEB项目中,应用在 Porlet环境.如果没有 Porlet环境那么 globalSession相当
于 session.

3. Bean 的生命周期的配置
   通过配置标签上的 init-method 作为 Bean 的初始化的时候执行的方法，配置 destroy-method
   作为 Bean的销毁的时候执行的方法。
   销毁方法想要执行，需要是单例创建的 Bean而且在工厂关闭的时候，Bean才会被销毁.

Spring 的 Bean 的管理 XML 的方式

1. Spring 生成 Bean 的时候三种方式(了解)
   【无参数的构造方法的方式（！！！！！！！！）

<!-- 方式一：无参数的构造方法的实例化 -->
<bean id="bean1" class="cn.test.spring.demo3.Bean1"></bean>

【静态工厂实例化的方式】
提供一个工厂类：

public class Bean2Factory {
	public static Bean2 getBean2(){
		return new Bean2();
	}
}

<!-- 方式二：静态工厂实例化 Bean -->
<bean id="bean2" class="cn.test.spring.demo3.Bean2Factory" factory-method="getBean2"/>

【实例工厂实例化的方式】

提供 Bean3的实例工厂:

public class Bean3Factory {
	public Bean3 getBean3(){
		return new Bean3();
	}
}

<!-- 方式三：实例工厂实例化 Bean -->
 <bean id="bean3Factory" class="cn.test.spring.demo3.Bean3Factory"></bean>
<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>

2. Spring 的 Bean 的属性注入
   【构造方法的方式注入属性】

<!-- 第一种：构造方法的方式 -->
<bean id="car" class="cn.test.spring.demo4.Car">
<constructor-arg name="name" value="保时捷"/>
<constructor-arg name="price" value="1000000"/>
</bean>

【set 方法的方式注入属性】

<!-- 第二种：set方法的方式 -->
<bean id="car2" class="cn.test.spring.demo4.Car2">
<property name="name" value="奇瑞 QQ"/>
<property name="price" value="40000"/>
</bean>

3. Spring 的属性注入：对象类型的注入

<!-- 注入对象类型的属性 -->
<bean id="person" class="cn.test.spring.demo4.Person">
<property name="name" value="会希"/>
<!-- ref属性：引用另一个 bean的 id或 name -->
<property name="car2" ref="car2"/>
</bean>

4. 名称空间 p 的属性注入的方式:Spring2.x 版本后提供的方式
   第一步:引入 p名称空间

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
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">

第二步:使用 p名称空间.
* 普通属性:p:属性名称=””
* 对象类型属性:p:属性名称-ref=””

<!-- p名称空间的属性注入的方式 -->
<bean id="car2" class="cn.test.spring.demo4.Car2" p:name="宝马 7"
p:price="1200000"/>
<bean id="person" class="cn.test.spring.demo4.Person" p:name="思聪"
p:car2-ref="car2"/>

5. SpEL 的方式的属性注入:Spring3.x 版本后提供的方式.
   SpEL：Spring Expression Language.
   语法:#{ SpEL }

<!-- SpEL的注入的方式 -->
<bean id="car2" class="cn.test.spring.demo4.Car2">
	<property name="name" value="#{'奔驰'}"/>
	<property name="price" value="#{800000}"/>
</bean>
<bean id="person" class="cn.test.spring.demo4.Person">
	<property name="name" value="#{'冠希'}"/>
	<property name="car2" value="#{car2}"/>
</bean>
<bean id="carInfo" class="cn.test.spring.demo4.CarInfo"></bean>
<!--引用了另一个类的属性-->
<bean id="car2" class="cn.test.spring.demo4.Car2">
<!--
<property name="name" value="#{'奔驰'}"/> -->
<property name="name" value="#{carInfo.carName}"/>
<property name="price" value="#{carInfo.calculatePrice()}"/>
</bean>

6. 注入复杂类型

<!-- Spring的复杂类型的注入===================== -->
<bean id="collectionBean" class="cn.test.spring.demo5.CollectionBean">
<!-- 数组类型的属性 -->
	<property name="arrs">
		<list>
			<value>会希</value>
			<value>冠希</value>
			<value>天一</value>
		</list>
	</property>
	<!-- 注入 List集合的数据 -->
	<property name="list">
		<list>
			<value>芙蓉</value>
			<value>如花</value>
			<value>凤姐</value>
		</list>
	</property>
	<!-- 注入 Map集合 -->
	<property name="map">
		<map>
			<entry key="aaa" value="111"/>
			<entry key="bbb" value="222"/>
			<entry key="ccc" value="333"/>
		</map>
	</property>
	<!-- Properties的注入 -->
	<property name="properties">
		<props>
			<prop key="username">root</prop>
			<prop key="password">123</prop>
		</props>
	</property>
</bean>

当集合中也是对象时

private List<Car> list1;

<bean id="car" class="cn.java.po.Car">
		<property name="id" value="1"></property>
		<property name="color" value="yellow"></property>
	</bean>

<property name="list1">
	<list>
		<ref bean="car"></ref>
		<ref bean="car"></ref>
	</list>	
</property>

7. Spring 的分配置文件的开发
   一种:创建工厂的时候加载多个配置文件

:
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");

二种:在一个配置文件中包含另一个配置文件：

<import resource="applicationContext2.xml"></import>