spring框架总结（01）

1、spring是什么？

sprint其实就是一个开源框架，是于2003年兴起的一个轻量级的java开发框架，是有Road Johnson创建的，简单的来说spring是一个分层的JavaSE/EE（full-stack）也就是一站式轻量级的开源框架

J2EE三层架构体系：

表现层（页面数据显示，页面跳转调度）jsp/servlet

业务层（业务处理和功能逻辑，事务控制） service

持久层（数据存取和封装和数据库打交道）dao

spring框架主要有：Spring MVC 和JDBCTemplate模块。

一般就是再使用的时候：在表现层使用Struts2和Spring MVC 在业务层使用的是Spring 在持久层使用的是hibernate和JDBCTemplate

2、Spring的核心技术

IOC（表示的是反转控制）也就是说将对象的创建权利交给Spring工场进行管理

AOP（表示的是面向切面编程）原理是基于动态代理功能增强

3、学习Spring技术的好处

(1)、方便解耦简化代码的开发-------Spring就是一个大工厂，可以将所有的对象的创建和关系的维护，交给Spring管理

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

(3)、声明事务的支持-------只需要进行配置就可以完成对事务的管理，而无需动手进行编程

(4)、方便程序的测试--------Spring对Junit4支持，可以通过注解方便测试你Spring程序，方便继承各种优秀的框架

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

总结介绍使用：

IOC（Inverse of Control）也就是控制反转就对象的创建权利交给Spring容器

解决问题：使用IOC可以解决程序耦合性过高的问题

IOC原理接受和准备工作

1、创建UserDao借口以及实现类UserDaoImpl

package cn.itcast.dao;

public interface UserDao {

public void save();

}

实现类

package cn.itcast.dao.impl;

import cn.itcast.dao.UserDao;

public class UserDaoImpl implements UserDao {

@Override

public void save() {

System.out.println("持久层：用户保存");

}

2、创建UserService借口和实现类UserServiceImpl

package cn.itcast.service;

public interface UserService {

public void save();

}

实现类

package cn.itcast.service.impl;

import cn.itcast.dao.UserDao;

import cn.itcast.dao.impl.UserDaoImpl;

import cn.itcast.service.UserService;

public class UserServiceImpl implements UserService {

private UserDao userDao = new UserDaoImpl();

@Override

public void save() {

System.out.println("业务层：用户保存");

userDao.save();

}

3、创建测试类测试

package cn.itcast.test;

import org.junit.Test;

import cn.itcast.service.UserService;

import cn.itcast.service.impl.UserServiceImpl;

public class Test1 {

@Test

public void test(){

UserService userService = new UserServiceImpl();

userService.save();

}

4、创建另一个UserDao借口的实现类UserDaoImpl2

package cn.itcast.dao.impl;

import cn.itcast.dao.UserDao;

public class UserDaoImpl2 implements UserDao{

@Override

public void save() {

System.out.println("持久层：用户保存2");

}

观察以上程序发现：UserService和UserDao耦合性过高，如果需要更换一个 UserDao的实现，则是需要修改源代码的

那么就是需要创建工厂类解决耦合性问题方法

工厂类的创建

package cn.itcast.utils;

import cn.itcast.dao.UserDao;

import cn.itcast.dao.impl.UserDaoImpl;

public class BeanFactory {

public static UserDao getBean(){

return new UserDaoImpl();

}

创建工厂类的时候接下来就是要修改上述代码（修改UserServiceImpl实现类来获取UserDao的方式）

修改代码如下：

public class UserServiceImpl implements UserService {

// private UserDao userDao = new UserDaoImpl();

// 采用工厂类获取UserDao对象

private UserDao userDao = BeanFactory.getBean();

@Override

public void save() {

System.out.println("业务层：用户保存");

userDao.save();

}

总结发现：这个时候观察总结发现：当需要更换UserDao的实现的时候，不需要修改UserServiceImpl类，不过此时需要进行修改工厂类

最终终极解决方法：可以创建配置文件彻底解决耦合性的问题

1、在src下创建配置文件beans.xml

<?xml version="1.0" encoding="UTF-8"?>

2、同时修改工厂类从配置文件中读取对象

代码如下：

public class BeanFactory {

//存放所有的对象

private static final Map<String,Object> map = new HashMap<String,Object>();

static{

SAXReader sax = new SAXReader();

try {

Document document = sax.read(BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml"));

Element root = document.getRootElement();

//获取id属性的值

String id = root.attributeValue("id");

//获取class属性的值

String value = root.attributeValue("class");

//根据class属性的值实例化对象

Object obj = Class.forName(value).newInstance();

//把对象存放到Map中

map.put(id, obj);

} catch (Exception e) {

e.printStackTrace();

}

/**

* 根据id获取对象

* @param id

* @return

public static Object getBean(String id){

return map.get(id);

}

3、修改UserServiceImpl类

public class UserServiceImpl implements UserService {

// private UserDao userDao = new UserDaoImpl();

// 采用工厂类获取UserDao对象

// private UserDao userDao = BeanFactory.getBean();

// 从配置文件中读取需要的对象

private UserDao userDao = (UserDao) BeanFactory.getBean("userDao");

@Override

public void save() {

System.out.println("业务层：用户保存");

userDao.save();

}

这个时候总结发现：当需要更改UserDao的时候，只需要修改配置文件就可以实现，不用更改源代码了，这个时候程序也就是会彻底解决耦合性过高的问题

3、Spring开发包的下载：

1.)官网地址：https://spring.io/

2）下载地址：http://repo.spring.io/libs-release-local/org/springframework/spring/ 建议下载4.2.4这个版本

介绍一个开发包的目录结构：

docs 表示的是开发文档

libs 表示开发时候所需要的jar包

schema：表示开发的时候所需要的约束文件

其他的暂时不用考虑

注意：开发过程中还需要其他开源技术框架依赖Jar包集（dependencies，作用是方便依赖的其他技术的jar的导入）

Spring核心容器中是需要四个jar包的：分别是beans 、context、Core、SpEl核心jar包

同时还需要加入和日志相关的两个jar包，从spring-framework-3.0.2.RELEASE-dependencies中寻找

5、介绍Spring中的工厂

5.1、 ApplicationContext接口

使用ApplicationContext工厂的接口，使用该接口可以获取到具体的Bean对象

该接口下有两个具体的实现类

ClassPathXmlApplicationContext -- 加载类路径下的Spring配置文件

FileSystemXmlApplicationContext -- 加载本地磁盘下的Spring配置文件

1.1. BeanFactory工厂

早期版本的工厂介绍：

BeanFactory是Spring框架早期的创建Bean对象的工厂接口

/**

* 早期版本的spring工厂：BeanFactory

@Test

public void test3(){

BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

System.out.println("工厂对象创建出来了");

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

userDao.save();

}

BeanFactory和ApplicationContext的区别
            *
BeanFactory   （表示的是早期的ioc工厂） --
BeanFactory采取延迟加载，第一次getBean时才会初始化Bean
            *
ApplicationContext        -- 在加载applicationContext.xml时候就会创建具体的Bean对象的实例，还提供了一些其他的功能:
                 * 事件传递
                 * Bean自动装配
                 * 各种不同应用层的Context实现

6、Spring配置文件的介绍

6.1 id属性：id属性是bean的唯一标识

6.2 class属性：表示的是bean的全路径名称 <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl"/>

6.3 Scope属性：scope属性代表Bean的作用范围

singleton:单例（默认值）

prototype:多例，在Spring框架整合Struts2框架的时候，Action类也需要交给Spring做管理，配置把Action类配置成多例！！

request:应用在web应用中，将创建的对象存入到request域中。

session:应用在web应用中，将创建的对象存入到session域中

globalsession:应用在porlet环境下使用。将创建的对象存入到全局的session中。

实例：

singleton:单例（默认值）

prototype:多例，在Spring框架整合Struts2框架的时候，Action类也需要交给Spring做管理，配置把Action类配置成多例！！

request:应用在web应用中，将创建的对象存入到request域中。

session:应用在web应用中，将创建的对象存入到session域中

globalsession:应用在porlet环境下使用。将创建的对象存入到全局的session中。

两者直接的区分：

修改测试类： ClassPathXMLApplication表示的你是直接从类路径下面进行加载，表示类只要一创建就立刻加载出来了。

@Test

public void test1(){

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

System.out.println("工厂对象创建出来了");

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

UserDao userDao1 = (UserDao) applicationContext.getBean("userDao");

userDao.save();

}

测试发现：当scope为prototype时，每次获取bean，都会重新实例化

6.4、init-method属性

当bean被载入到容器的时候调用init-method属性指定的方法

public class UserDaoImpl implements UserDao {

public UserDaoImpl() {

System.out.println("调用了UserDaoImpl的构造方法");

}

public void init(){

System.out.println("调用了init方法...");

}

@Override

public void save() {

System.out.println("用户保存...");

}

实例：

6.5、 destory-method属性

当bean从容器中删除的时候调用destroy-method属性指定的方法

想查看destroy-method的效果，有如下条件：

scope= singleton有效

web容器中会自动调用，但是main函数或测试用例需要手动调用（需要使用ClassPathXmlApplicationContext的close()方法）

@Test

public void test1(){

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

System.out.println("工厂对象创建出来了");

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

userDao.save();

//要看到destroy方法执行，需要调用ClassPathXmlApplicationContext.close方法

((ClassPathXmlApplicationContext)applicationContext).close();

}

总结：就是Spring框架的5中属性，分别是id属性，class属性，scope属性，init-method属性，destory-method属性

7、Spring生成bean的三种方式

7.1 表示无参构造方法--------------默认调用无参构造方法实例化bean

7.2 静态工厂实例化方式----------通过调用工厂类的静态方法实例化生成bean

n 编写DepartmentDao接口

package cn.itcast.dao;

public interface DepartmentDao {

public void save();

}

n 编写DepartmentDaoImpl实现类

package cn.itcast.dao.impl;

import cn.itcast.dao.DepartmentDao;

public class DepartmentDaoImpl implements DepartmentDao{

@Override

public void save() {

System.out.println("部门保存...");

}

n 编写工厂类

package cn.itcast.dao.impl;

import cn.itcast.dao.DepartmentDao;

public class DepartmentDaoFactory {

/**

* 静态工厂方法获取对象

* @return

public static DepartmentDao create(){

return new DepartmentDaoImpl();

}

n 编写applicationContext.xml配置文件

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

</beans>

7.3 实例工厂方式

n 实例工厂代码:

package cn.itcast.dao.impl;

import cn.itcast.dao.DepartmentDao;

public class DepartmentDaoFactory {

/**

* 静态工厂方法获取对象

* @return

public static DepartmentDao create(){

return new DepartmentDaoImpl();

}

/**

* 实例工厂方法获取对象

* @return

public DepartmentDao create1(){

return new DepartmentDaoImpl();

}

n 编写applicationContext.xml

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

</beans>

总结：Spring生成bean的三种方式：无参构造方法，静态工厂实例化方式，实力工厂方式

8、依赖注入（重点学习使用）（其中有八种方法可以实现依赖注入实现）

依赖注入的介绍：

IOC和DI的概念：
        *
IOC        -- Inverse of Control，控制反转，将对象的创建权反转给Spring！！
        *
DI        -- Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中！！

如果UserServiceImpl的实现类中有一个属性，那么使用Spring框架的IOC功能时，可以通过依赖注入把该属性的值传入进来！！

总共有八种：

1、构造方法注入

package cn.itcast.domain;

public class Car implements Serializable{

private static final long serialVersionUID = 1L;

private String name;

private Double price;

public Car(String name, Double price) {

this.name = name;

this.price = price;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Double getPrice() {

return price;

}

public void setPrice(Double price) {

this.price = price;

}

@Override

public String toString() {

return "Car [name=" + name + ", price=" + price + "]";

}

n 配置applicationContext.xml

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

<constructor-arg name="name" value="奥迪A6"></constructor-arg>

<constructor-arg name="price" value="57.3"></constructor-arg>

</bean>

</beans>

2、set方法注入

public class Student implements Serializable {

private static final long serialVersionUID = 1L;

private Long id;

private String name;

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return "Student [id=" + id + ", name=" + name + "]";

}

n 配置applicationContext.xml

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

<constructor-arg name="name" value="奥迪A6"></constructor-arg>

<constructor-arg name="price" value="57.3"></constructor-arg>

</bean>

</bean>

</beans>

3、set方法注入的其他写法（不常用）

3.1 p命名空间的写法

新建car1类

package cn.itcast.domain;

public class Car1 {

private String name;

private double price;

public void setName(String name) {

this.name = name;

}

在applicationContext.xml中引入p命名空间

public void setPrice(double price) {

this.price = price;

}

@Override

public String toString() {

return "Car1 [name=" + name + ", price=" + price + "]";

}

spring框架总结（01）

n 采用p:属性名的形式注入值（spring2.5提供的）

</bean>

SpEL的写法（spring3.0提供）

</bean>

注入字符串：#{‘字符串’}

注入数字：#{数字}

注入其它对象：#{对象id}

</bean>

n 还可以注入其它对象的属性或方法的返回值

public class CarInfo {

public String getCarName(){

return "宝骏560";

}

public double calculatePrice(){

return Math.random() * 10000;

}

<!-- <property name="name" value="#{'哈弗H5'}"></property>

</bean>

注意：#{carInfo.carName}会调用getCarName方法获取汽车的名称；而#{carInfo.calculatePrice()}会直接调用calculatePrice方法获取汽车价格。

5、数组或者是list注入

数组和list注入的写法是一样的

n 新建bean类

public class CollectionBean {

private String[] array;

public void setArray(String[] array) {

this.array = array;

}

@Override

public String toString() {

return "CollectionBean [array=" + Arrays.toString(array) + "]";

}

n 在applicationContext.xml中配置

<list>

</list>

</property>

</bean>

6.Set集合注入

public class CollectionBean {

private String[] array;

private Set<String> set;

public void setArray(String[] array) {

this.array = array;

}

public void setSet(Set<String> set) {

this.set = set;

}

@Override

public String toString() {

System.out.println(set.getClass());

return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + "]";

}

<list>

</list>

</property>

<set>

</set>

</property>

</bean>

提示：spring在注入set的时，给我们注入的是一个LinkedHashSet，所以在输入set集合中的元素时，是按照我们注入的顺序来的，并不是无序的。

7Map集合的注入

public class CollectionBean {

private String[] array;

private Set<String> set;

private Map<String,String> map;

public void setArray(String[] array) {

this.array = array;

}

public void setSet(Set<String> set) {

this.set = set;

}

public void setMap(Map<String, String> map) {

this.map = map;

}

@Override

public String toString() {

return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + ", map=" + map + "]";

}

<list>

</list>

</property>

<set>

</set>

</property>

<map>

</map>

</property>

</bean>

8、properties集合的注入

public class CollectionBean {

private String[] array;

private Set<String> set;

private Map<String,String> map;

private Properties props;

public void setArray(String[] array) {

this.array = array;

}

public void setSet(Set<String> set) {

this.set = set;

}

public void setMap(Map<String, String> map) {

this.map = map;

}

public void setProps(Properties props) {

this.props = props;

}

@Override

public String toString() {

return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + ", map=" + map + ", props=" + props

+ "]";

}

<list>

</list>

</property>

<set>

</set>

</property>

<map>

</map>

</property>

<props>

</props>

</property>

</bean>

1.1. 配置文件的分离

Spring配置文件的分离有两种方式：

（1）采用import标签导入另一个配置文件

Bean1类

public class Bean1 {

private String xxx;

public String getXxx() {

return xxx;

}

public void setXxx(String xxx) {

this.xxx = xxx;

}

@Override

public String toString() {

return "Bean1 [xxx=" + xxx + "]";

}

applicationContext2.xml

<?xml version="1.0" encoding="UTF-8"?>

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

</bean>

</beans>

在applicationContext.xml中引入applicationContext2.xml文件

（2）在实例化ApplicationContext的时候，指定多个配置文件

@Test

public void test9(){

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

Bean1 bean1 = (Bean1) ac.getBean("bean1");

System.out.println(bean1);

}

秒客网

spring框架总结（01）

1.1. BeanFactory工厂

SpEL的写法（spring3.0提供）

1.1. 配置文件的分离

相关文章