Spring框架--开篇

一.什么是Spring

Spring是一个JavaSE/EE的full-stack（一栈式）框架。Spring框架有EE每层的解决方案。

WEB层：Spring MVC

Service层：Spring的Bean管理，Spring的事务管理

DAO层：Spring的JDBC模板，ORM模块用于整合其他的持久层框架。

 

二 .Spring的优点

 

三 .Spring入门

IOC:控制反转。把创建对象（new）的操作交给Spring框架。

SpringIOC入门步骤：

1、创建项目，并添加jar包 (6个)

1>依赖包中的俩个日志包

com.springsource.org.apache.commons.logging-1.1.1.jar

com.springsource.org.apache.log4j-1.2.15.jar

2> 框架的jar

spring-beans-4.2.4.RELEASE.jar

spring-context-4.2.4.RELEASE.jar

spring-core-4.2.4.RELEASE.jar

spring-expression-4.2.4.RELEASE.jar

2、创建类（dao）

3、编写配置文件

必须在src下创建xml文件（一般叫applicationContext.xml

4、导入约束：

spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html中找到 ------40.2.12 the beans schema 然后复制约束文件添加到我们创建的xml中去

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

<!-- 实例化对象：IOC -->

<bean id="userDao" class="com.csq.study.AdminDaoImpl"></bean> </beans>

5、测试

//创建解析xml文件的工厂类（Spring容器）

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

UserDao userDao = (UserDao) ac.getBean("userDao");

userDao.save();

DI：依赖注入。依赖：在创建对象的前提下。 注入：给属性赋值。

依赖注入：在IOC的前提下，给属性赋值。

<!--IOC:创建对象 -->

<bean id="UserDao" class="com.csq.study.UserDaoImpl">

<!--DL：依赖注入， name调用的是set方法 -->

<property name="username" value="jack"></property>

</bean>

四，Spring的工厂：(了解)

//ApplicationContext与FileSystemXmlApplicationContext的区别

public void test3(){

//ClassPathXmlApplicationContext :加载类路径下的配置文件。

//ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

//FileSystemXmlApplicationContext :加载文件系统中的配置文件。

ApplicationContext ac = new FileSystemXmlApplicationContext("d:/applicationContext.xml");

UserDao userDao = (UserDao) ac.getBean("userDao");

userDao.save();

}

//BeanFactory和ApplicationContext的区别

public void test4(){

//ApplicationContext在加载配置文件时就创建所有Bean对象了。

//ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

//Bean bean = (Bean)ac.getBean("bean");

//BeanFactory在调用getBean的时候创建这个类的实例对象。而且只能读取系统盘上的文件

BeanFactory bf = new XmlBeanFactory(new FileSystemResource("d:/applicationContext.xml"));

Bean b1 = (Bean)bf.getBean("bean");

Bean b2 = (Bean)bf.getBean("bean");

System.out.println(b1==b2);

}

2、XML的配置**

<bean id="" class="" scope="" init-method="" destroy-method=""/>

bean标签作用：实例化类的。IOC

id: 用来配置Bean的名称，使用了Schema中唯一的约束。id属性中不能出现特殊字符。

name: 用来配置Bean的名称，没有使用Schema中唯一的约束。name属性中可以出现特殊字符。

class: 属性用于配置类的全路径，用于工厂类反射生成这个类的实例。

**scope: prototype（多例）|singleton(默认) 单例**

init-method：表示初始化方法

destroy-method ：销毁方法

3.Spring配置：

bean标签：实例化对象

id: 值唯一，不能写特殊字符。

name：用来配置Bean的名称，没有使用Schema中唯一的约束。name属性中可以出现特殊字符。

class：属性用于配置类的全路径，用于工厂类反射生成这个类的实例。

scope：配置对象的单例（默认）或多例 *

init-method和

destroy-method(了解)

//对于destroy-method的使用要求：1、必须使用单例(scope="singleton") 2、关闭容器(ac.close)

4. scope属性

（一旦使用属性scope="prototype",那么容器不会帮你创建对象了）

1.4.2.3scope属性

scope属性用于描述Bean的作用范围的。

scope属性中有如下几个取值

singleton :默认值，Spring创建这个类的时候默认使用单例模式。采用了单例模式 一旦 ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");

那么就会创建对象

prototype :Spring创建这个类的时候采用多例模式。此时，不会再帮你new对象，

Bean bean1 = (Bean) ac.getBean("bean"); 就创建一个对象

 

request :应用web开发，创建一个对象，将这个对象存入到request域中。

session :应用web开发，创建一个对象，将这个对象存入到session域中。

globalSession :应用web开发，应用在porlet环境中，没有这个环境的话与session等价的。

 

四、Spring实例化类的方式： IOC

 

**1、无参构造实例化** （重要）

 

~~~xml

<!-- 1、无参构造实例化 -->

<bean id="bean1" class="com.csq.study.Bean1"></bean>

~~~

 

**2、静态工厂实例化**

创建一个静态工厂

public class BeanFactory {

public static Bean2 addBeanFactory(){

return new Bean2();

}

}

~~~xml

<!-- 2、静态工厂实例化 -->

<bean id="bean2" class="com.csq.study.Bean2Factory" factory-method="createBean2"></bean>

~~~

**3、实例工厂实例化**

创建一个bean3Factory类，public class BeanFactory3 {

public Bean3 addBeanFactory2(){

return new Bean3();

}

}

~~~xml

<!-- 3、实例工厂实例化 -->

<bean id="bean3Factory" class="com.csq.study.Bean3Factory"></bean

<bean id="bean3" factory-bean="bean3Factory" factory-method="createBean3"></bean>

~~~

 

五、Spring属性注入的方式：DI

<!-- 1、构造方法注入 -->

<bean id="car1" class="com.csq.study.Car1">

<constructor-arg name="name" value="宾利"/>

<constructor-arg name="money" value="2000000"/>

</bean>

<!-- 2、set方法注入: 普通类型 -->

<bean id="car2" class="com.csq.study.Car2">

<property name="name" value="三轮"/>

<property name="money" value="10000"/>

</bean>

~~~

~~~XML

<!-- 3、set方法注入: 对象类型 -->

<bean id="emp1" class="com.csq.study.Employee">

<property name="username" value="有福"/>

<property name="car" ref="car1"/>

</bean>

~~~

语法：

 

​ 对于普通类型属性注入： p:username="tom"

​ 对于对象类型属性注入： p:car-ref="car1"

~~~xml

<!-- 4、p名称空间注入 -->

还需要在配置文件中加一个约束条件 ： xmlns:p="http://www.springframework.org/schema/p"

<bean id="emp2" class="com.csq.study.Employee" p:username="小白" p:car-ref="car1"/>~~~

<!-- 5、SpEL表达式注入 -->

<bean id="calc" class="com.csq.study.Calc"/>

<bean id="car2" class="com.csq.study.Car2">

<property name="name" value="#{'三轮'}"/>

<property name="money" value="#{calc.getMoney()}"/>

</bean>

~~~

 

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

<bean id="collectionBean" class="com.csq.study.CollectionBean">

<!-- 给数组赋值 -->

<property name="arr">

<array>

<value>aa</value>

<value>bb</value>

<value>mm</value>

<value>sb</value>

</array>

</property>

<!-- 给list集合赋值 -->

<property name="list">

<list>

<value>aaa</value>

<value>bbb</value>

<ref bean="car2"/>

</list>

</property>

<!-- 给set集合赋值 -->

<property name="set">

<set>

<value>aaaa</value>

<ref bean="car1"/>

</set>

</property>

<!-- 给map赋值 -->

<property name="map">

<map>

<entry key="a" value="aa"/>

<entry key="b" value-ref="car1"/>

</map>

</property>

<!-- 给properties赋值 -->

<property name="prop">

<props>

<prop key="a">aaa</prop>

<prop key="b">bbb</prop>

</props>

</property>

</bean>