Spring总结

IOC & AOP & Spring JDBC Template & 声明式事务

IOC
一、Spring概述
- 1.Spring是什么
- 2.Spring发展历程
- 3.Spring优势
- 4.Spring体系结构
二、初识IOC
- 1.概述
- 2.自定义IOC容器
- - ①介绍
  - ②实现
  - - a.创建java项目，导入自定义IOC相关坐标
    - b.编写Dao接口和实现类
    - c.编写Service接口和实现类
    - d.编写测试代码
    - e.问题
    - f.编写beans.xml
    - g.编写BeanFactory工具类
    - h.修改UserServiceImpl实现类
- 3.知识小结
三 Spring快速入门
- 1.介绍
- 2. 实现
- - ①创建java项目，导入spring开发基本坐标
  - ②编写Dao接口和实现类
  - ③创建spring核心配置文件
  - ④在spring配置文件中配置 UserDaoImpl
  - ⑤使用spring相关API获得Bean实例
- 3.知识小结
四、Spring相关API
- 1.API继承体系介绍
- 2.BeanFactory
- 3.ApplicationContext
- 4.知识小结
五、Spring配置文件
- 1.Bean标签基本配置
- 2.Bean标签范围配置
- 3.Bean生命周期配置
- 4.Bean实例化三种方式
- - ①无参构造方法实例化
  - ②工厂静态方法实例化
  - ③工厂普通方法实例化
- 5.Bean依赖注入概述
- 6.Bean依赖注入方式
- - ①构造方法
  - ②set方法
  - ③P命名空间注入
- 7.Bean依赖注入的数据类型
- - ①注入普通数据类型
  - ②注入集合数据类型
  - - a.List集合注入
    - b.Set集合注入
    - c.Array数组注入
    - d.Map集合注入
    - e.Properties配置注入
- 8.配置文件模块化
- - ①并列的多个配置文件
  - ②主从配置文件
- 9.知识小结
六、DbUtils（IOC实战）
- 1.DbUtils是什么
- 2.Spring的xml整合DbUtils
- - ①介绍
  - ②实现
  - - a.准备数据库环境
    - b.创建java项目，导入坐标
    - c.编写Account实体类
    - d.编写AccountDao接口和实现类
    - e.编写AccountService接口和实现类
    - f.编写spring核心配置文件
    - g.编写测试代码
    - h.抽取jdbc配置文件
- 3.知识小结
七、Spring注解开发
- 1.Spring常用注解
- - ①介绍
  - ②实现
  - - a.Bean实例化（IOC）
    - b.属性依赖注入（DI）
    - c.@Value
    - d.@Scope
    - e.Bean生命周期
- 2.Spring常用注解整合DbUtils
- - ①拷贝xml配置项目，改为常用注解配置项目
  - ②修改AccountDaoImpl实现类
  - ③修改AccountServiceImpl实现类
  - ④修改spring核心配置文件
  - ⑤编写测试代码
- 3.Spring新注解
- 4.Spring纯注解整合DbUtils
- - ①编写Spring核心配置类
  - ②编写数据库配置信息类
  - ③编写测试代码
八、Spring整合Junit
- 1.普通Junit测试问题
- 2.Spring整合Junit
- - ①导入spring集成Junit的坐标
  - ②使用@Runwith注解替换原来的运行器
  - ③使用@ContextConfiguration指定配置文件或配置类
  - ④使用@Autowired注入需要测试的对象
  - ⑤创建测试方法进行测试
AOP
九、转账案例
- 1.基础功能
- - ①创建java项目，导入坐标
  - ②编写Account实体类
  - ③编写AccountDao接口和实现类
  - ④编写AccountService接口和实现类
  - ⑤编写spring核心配置文件
  - ⑥编写测试代码
  - ⑦问题分析
- 2.传统事务
- - ①编写线程绑定工具类
  - ②编写事务管理器
  - ③修改service层代码
  - ④修改dao层代码
  - ⑤问题分析
十、Proxy优化转账案例
- 1.JDK动态代理方式
- 2.CGLIB动态代理方式
十一、初识AOP
- 1.什么是AOP
- 2.AOP底层实现
- 3.AOP相关术语
- 4.AOP开发明确事项
- - ①开发阶段（我们做的）
  - ②运行阶段（Spring框架完成的）
  - ③底层代理实现
- 5.知识小结
十二、基于XML的AOP开发
- 1.快速入门
- - ①创建java项目，导入AOP相关坐标
  - ②创建目标接口和目标实现类
  - ③创建通知类
  - ④将目标类和通知类对象创建权交给spring
  - ⑤在核心配置文件中配置织入关系及切面
  - ⑥编写测试代码
- 2.XML配置AOP详解
- - ①切点表达式
  - ②通知类型
- 3. 知识小结
十三、基于注解的AOP开发
- 1.快速入门
- - ①创建java项目，导入AOP相关坐标
  - ②创建目标接口和目标实现类
  - ③创建通知类
  - ④将目标类和通知类对象创建权交给spring
  - ⑤ 在通知类中使用注解配置织入关系，升级为切面类
  - ⑥在配置文件中开启组件扫描和 AOP 的自动代理
  - ⑦编写测试代码
- 2.注解配置AOP详解
- - ①切点表达式
  - ② 通知类型
  - ③纯注解配置
- 3.知识小结
十四、AOP优化转账案例
- 1.xml配置实现
- - ①配置文件
  - ②事务管理器（通知）
- 2.注解配置实现
- - ①配置文件
  - ②事务管理器（通知）
Spring JDBCTemplate & 声明式事务
十五、Spring的JdbcTemplate
- 1.JdbcTemplate是什么？
- 2.Spring整合JdbcTemplate
- - ①创建java项目，导入坐标
  - ②编写Account实体类
  - ③编写AccountDao接口和实现类
  - ④编写AccountService接口和实现类
  - ⑤编写spring核心配置文件
  - ⑥编写测试代码
- 3. 实现转账案例
- - ①创建java项目，导入坐标
  - ②编写Account实体类
  - ③编写AccountDao接口和实现类
  - ④编写AccountService接口和实现类
  - ⑤编写spring核心配置文件
  - ⑥编写测试代码
十六、Spring的事务
- 1.Spring中的事务控制方式
- 2.编程式事务控制相关对象
- - ①PlatformTransactionManager
  - ②TransactionDefinition
  - - a.事务隔离级别
    - b.事务传播行为
  - ③TransactionStatus
  - - ④实现代码
    - a.配置文件
    - b.业务层代码
  - ⑤知识小结
- 3.基于XML的声明式事务控制
- - ①快速入门
  - - a.引入tx命名空间
    - b.事务管理器通知配置
    - c.事务管理器AOP配置
    - d.测试事务控制转账业务代码
  - ②事务参数的配置详解
  - ③知识小结
- 4.基于注解的声明式事务控制
- - ①常用注解
  - - a.修改service层，增加事务注解
    - b.修改spring核心配置文件，开启事务注解支持
  - ②纯注解
  - ③知识小结
十七、Spring集成web环境
- 1.ApplicationContext应用上下文获取方式
- 2.Spring提供获取应用上下文的工具
- 3.实现
- - ①导入Spring集成web的坐标
  - ②配置ContextLoaderListener监听器
  - ③通过工具获得应用上下文对象

务)

IOC 一、Spring概述 1.Spring是什么

Spring是分层的Java SE/EE应用 full-stack(全栈式) 轻量级开源框架。
提供了表现层 SpringMVC和持久层 Spring JDBC Template以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。
两大核心：以 IOC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

2.Spring发展历程

EJB
1997 年，IBM提出了EJB 的思想
1998 年，SUN制定开发标准规范 EJB1.0
1999 年，EJB1.1 发布
2001 年，EJB2.0 发布
2003 年，EJB2.1 发布
2006 年，EJB3.0 发布
Spring
Rod Johnson（ Spring 之父）
　改变Java世界的大师级人物
2002年编著《Expert one on one J2EE design and development》
　指出了JavaEE和EJB组件框架中的存在的一些主要缺陷；提出普通java类依赖注>入更为简单的解决方案。
2004年编著《Expert one-on-one J2EE Development without EJB》
　阐述了JavaEE开发时不使用EJB的解决方式（Spring 雏形）
　同年4月spring1.0诞生
2006年10月，发布 Spring2.0
2009年12月，发布 Spring3.0
2013年12月，发布 Spring4.0
2017年9月，发布最新 Spring5.0 通用版（GA）

3.Spring优势

①方便解耦，简化开发
Spring就是一个容器，可以将所有对象创建和关系维护交给Spring管理
什么是耦合度？对象之间的关系，通常说当一个模块(对象)更改时也需要更改其他模块(对象)，这就是耦合，耦合度过高会使代码的维护成本增加。要尽量解耦
②AOP编程的支持
Spring提供面向切面编程，方便实现程序进行权限拦截，运行监控等功能。
③声明式事务的支持
通过配置完成事务的管理，无需手动编程
④方便测试，降低JavaEE API的使用
Spring对Junit4支持，可以使用注解测试
⑤方便集成各种优秀框架
不排除各种优秀的开源框架，内部提供了对各种优秀框架的直接支持

4.Spring体系结构

二、初识IOC 1.概述

**控制反转(Inverse Of Control)**不是什么技术，而是一种设计思想。它的目的是指导我们设计出更加松耦合的程序。

控制：在java中指的是对象的控制权限（创建、销毁）
反转：指的是对象控制权由原来由开发者在类中手动控制反转到由Spring容器控制

比如

传统方式
之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();
IOC方式
现在我们需要一个userDao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制

2.自定义IOC容器 ①介绍

需求
实现service层与dao层代码解耦合
步骤分析:
　a.创建java项目，导入自定义IOC相关坐标
　b.编写Dao接口和实现类
　c.编写Service接口和实现类
　d.编写测试代码

②实现 a.创建java项目，导入自定义IOC相关坐标

b.编写Dao接口和实现类

public interface UserDao {
	public void save();
}

public class UserDaoImpl implements UserDao {
	public void save() {
		System.out.println("保存成功了...");
	}
}

c.编写Service接口和实现类

public interface UserService {
	public void save();
}

public class UserServiceImpl implements UserService {
	public void save(){
		UserDao userDao = new UserDaoImpl();
		userDao.save();
	}
}

d.编写测试代码

public class UserTest {
	@Test
	public void testSave() throws Exception {
		UserService userService = new UserServiceImpl();
		userService.save();
	}
}

e.问题

当前service对象和dao对象耦合度太高，而且每次new的都是一个新的对象，导致服务器压力过大。

解耦合的原则是编译期不依赖，而运行期依赖就行了

通过反射修改UserServieceImpl.java

public class UserServiceImpl implements UserService {

    public void save() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //调用dao层方法 传统方式：new存在编译器依赖 耦合重
        //UserDao userDao = new UserDaoImpl();
        //反射
        UserDao userDao = (UserDao)Class.forName("com.spring.dao.impl.UserDaoImpl").newInstance();
        userDao.save();
    }
}

此时又会出现硬编码问题，所以需要配置文件

f.编写beans.xml

把所有需要创建对象的信息定义在配置文件中

g.编写BeanFactory工具类

public class BeanFactory {
    private static Map iocmap = new HashMap<>();
    //程序启动时，初始化对象实例
    static {
        //1.读取配置文件
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
        //2.解析xml(dom4j)
        SAXReader saxReader = new SAXReader();
        try {
            document document = saxReader.read(resourceAsStream);
            //3.编写xpath表达式
            String xpath = "//bean";
            //4.获取到所有的bean标签
            List list = document.selectNodes(xpath);
            //5.遍历并使用反射创建对象实例，存到map集合(ioc容器)中
            for (Element element : list) {
                String id = element.attributevalue("id");
                //className = com.lagou.dao.impl.UserDaoImpl
                String className = element.attributevalue("class");
                //使用反射生成实例对象
                Object o = Class.forName(className).newInstance();
                //存到map中 key id:value o
                iocmap.put(id,o);
            }
        } catch (documentException | ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
    //获取指定id的对象实例
    public static Object getBean(String beanId){
        Object o = iocmap.get(beanId);
        return o;
    }
}

h.修改UserServiceImpl实现类

public class UserServiceImpl implements UserService {
	public void save() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //调用dao层方法 传统方式：new存在编译器依赖 耦合重
        //UserDao userDao = new UserDaoImpl();
        //反射
        //UserDao userDao = (UserDao)Class.forName("com.spring.dao.impl.UserDaoImpl").newInstance();
        UserDao userDao = (UserDao)BeanFactory.getBean("userDao");
        userDao.save();
    }
}

3.知识小结

其实升级后的BeanFactory就是一个简单的Spring的IOC容器所具备的功能。
之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();
现在我们需要一个userdao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制
最终目标：代码解耦合

三 Spring快速入门 1.介绍

需求：借助spring的IOC实现service层与dao层代码解耦合
步骤分析

创建java项目，导入spring开发基本坐标
编写Dao接口和实现类
创建spring核心配置文件
在spring配置文件中配置 UserDaoImpl
使用spring相关API获得Bean实例

2. 实现 ①创建java项目，导入spring开发基本坐标


	
		org.springframework
		spring-context
		5.1.5.RELEASE
	
	
		junit
		junit
		4.12

②编写Dao接口和实现类

public interface UserDao {
	public void save();
}

public class UserDaoImpl implements UserDao {
	public void save() {
		System.out.println("dao层被调用了...");
	}
}

③创建spring核心配置文件

④在spring配置文件中配置 UserDaoImpl

⑤使用spring相关API获得Bean实例

@Test
    public void test1(){
        //1.获取到spring上下文对象 借助上下文对象可以获取到IOC容器中的bean对象
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.使用上下文对象从IOC容器中获取到Bean对象
        IUserDao userDao = (IUserDao)classPathXmlApplicationContext.getBean("userDao");
        //3.调用方法
        userDao.save();
    }

3.知识小结

Spring的开发步骤

导入坐标
创建Bean
创建applicationContext.xml
在配置文件中进行Bean配置
创建ApplicationContext对象，执行getBean

四、Spring相关API 1.API继承体系介绍

Spring的API体系异常庞大，我们现在只关注两个BeanFactory和ApplicationContext

2.BeanFactory

BeanFactory是 IOC 容器的核心接口，它定义了IOC的基本功能
特点：在第一次调用getBean()方法时，创建指定对象的实例

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

3.ApplicationContext

代表应用上下文对象，可以获得spring中IOC容器的Bean对象
特点：在spring容器启动时，加载并创建所有对象的实例
常用实现类

ClassPathXmlApplicationContext
它是从类的根路径下加载配置文件推荐使用这种。
FileSystemXmlApplicationContext
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext
当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

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

常用方法

Object getBean(String name);
根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。
< T > T getBean(Class< T > requiredType);
根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。
< T > T getBean(String name,Class< T > requiredType);
根据Bean的id和类型获得Bean实例，解决容器中相同类型Bean有多个情况。

4.知识小结

ApplicationContext app = new ClasspathXmlApplicationContext("xml文件");
//1.根据beanid在容器中找对应的bean对象
IUserDao userDao = (IUserDao)classPathXmlApplicationContext.getBean("userDao");
//2.根据类型在容器中查询  有可能报错情况：根据当前类型匹配到多个实例
IUserDao userDao = classPathXmlApplicationContext.getBean(IUserDao.class);

五、Spring配置文件 1.Bean标签基本配置

< bean id="" >

用于配置对象交由Spring来创建。
基本属性：
　id：Bean实例在Spring容器中的唯一标识
　class：Bean的全限定名
默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

2.Bean标签范围配置

scope属性指对象的作用范围，取值如下：

当scope的取值为singleton时
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
Bean的生命周期：
　对象创建：当应用加载，创建容器时，对象就被创建了
　对象运行：只要容器在，对象一直活着
　对象销毁：当应用卸载，销毁容器时，对象就被销毁了
当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bean
Bean的生命周期：
　对象创建：当使用对象时，创建新的对象实例
　对象运行：只要对象在使用中，就一直活着
　对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

3.Bean生命周期配置


　* init-method：指定类中的初始化方法名称
　* destroy-method：指定类中销毁方法名称

public class UserDaoImpl implements IUserDao {
    public void init(){
        System.out.println("初始化方法执行了。。。");
    }
    public void destory(){
        System.out.println("销毁方法执行了。。。");
    }
    public void save() {
        System.out.println("DAO被调用了...");
    }
}

@Test
    public void test2(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);
        System.out.println(userDao2);
        //手动销毁
        //applicationContext.close();
    }

4.Bean实例化三种方式

无参构造方法实例化
工厂静态方法实例化
工厂普通方法实例化

①无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

②工厂静态方法实例化

应用场景
依赖的jar包中有个A类，A类中有个静态方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class StaticFactoryBean {
    public static IUserDao creatUserDao(){
        return new UserDaoImpl();
    }
}

③工厂普通方法实例化

应用场景
依赖的jar包中有个A类，A类中有个普通方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class DynamicFactoryBean {
    public IUserDao creatUserDao(){
        return new UserDaoImpl();
    }
}

5.Bean依赖注入概述

依赖注入DI(Dependency Injection):它是Spring框架核心 IOC 的具体实现。
　在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
　那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

6.Bean依赖注入方式 ①构造方法

在UserServiceImpl中创建有参构造

public class UserServiceImpl implements IUserService {
    private IUserDao userDao;
    public UserServiceImpl(IUserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void save() {
        //调用dao层的save方法
        userDao.save();
    }
}

配置Spring容器调用有参构造时进行注入

②set方法

在UserServiceImpl中创建set方法

public class UserServiceImpl implements UserService {
	private UserDao userDao;
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	@Override
	public void save() {
		userDao.save();
	}
}

配置Spring容器调用set方法进行注入

③P命名空间注入

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：
引入P命名空间：

xmlns:p="http://www.springframework.org/schema/p"

修改注入方式：

7.Bean依赖注入的数据类型

上面操作，都是注入Bean对象，除了对象的引用可以注入，普通数据类型和集合都可以在容器中进行注入。
注入数据的三种数据类型

普通数据类型
引用数据类型
集合数据类型

其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的。下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入。

①注入普通数据类型

public class UserDaoImpl implements IUserDao {
		private String username;
    private Integer age;

    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    public void save() {
        System.out.println(username);
        System.out.println(age);
        System.out.println("DAO被调用了...");
    }
}

②注入集合数据类型 a.List集合注入

public class UserDaoImpl implements UserDao {
	private List

Spring总结

Java相关栏目本月热门文章