一、spring的概述

spring是什么：全栈轻量级开源框架
spring的两大核心：IOC、AOP
spring的发展历程和优势：
1. 方便解耦，简化开发
2. aop编程的支持
3. 声明式事务的支持
4. 方便程序的测试
5. 方便集成各种优秀框架
6. 降低 JavaEE API 的使用难度
7. Java 源码是经典学习范例

spring体系结构

二、程序的耦合及解耦

曾经案例中问题

JdbcDemo.java

/*** 程序的耦合*      耦合：程序间的依赖关系*          包括：*              类之间的依赖*              方法间的依赖*      解耦：*          降低程序间的依赖关系*      实际开发中：*          应该做到：编译期不依赖，运行时才依赖。*      解耦的思路：*          第一步：使用反射来创建对象，而避免使用new关键字。*          第二步：通过读取配置文件来获取要创建的对象全限定类名**/
public class JdbcDemo1 {public static void main(String[] args) throws  Exception{//1.注册驱动
//        DriverManager.registerDriver(new com.mysql.jdbc.Driver());Class.forName("com.mysql.jdbc.Driver");//2.获取连接Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/eesy","root","1234");//3.获取操作数据库的预处理对象PreparedStatement pstm = conn.prepareStatement("select * from account");//4.执行SQL，得到结果集ResultSet rs = pstm.executeQuery();//5.遍历结果集while(rs.next()){System.out.println(rs.getString("name"));}//6.释放资源rs.close();pstm.close();conn.close();}
}

工厂模式解耦

bean.properties

accountService=com.weilai.service.impl.AccountServiceImpl
accountDao=com.weilai.dao.impl.AccountDaoImpl

BeanFactory.java

/*** 一个创建Bean对象的工厂** Bean：在计算机英语中，有可重用组件的含义。* JavaBean：用java语言编写的可重用组件。*      javabean >  实体类**   它就是创建我们的service和dao对象的。**   第一个：需要一个配置文件来配置我们的service和dao*           配置的内容：唯一标识=全限定类名（key=value)*   第二个：通过读取配置文件中配置的内容，反射创建对象**   我的配置文件可以是xml也可以是properties*/
public class BeanFactory {//定义一个Properties对象private static Properties props;//定义一个Map,用于存放我们要创建的对象。我们把它称之为容器private static Map<String,Object> beans;//使用静态代码块为Properties对象赋值static {try {//实例化对象props = new Properties();//获取properties文件的流对象InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");props.load(in);//实例化容器beans = new HashMap<String,Object>();//取出配置文件中所有的KeyEnumeration keys = props.keys();//遍历枚举while (keys.hasMoreElements()){//取出每个KeyString key = keys.nextElement().toString();//根据key获取valueString beanPath = props.getProperty(key);//反射创建对象Object value = Class.forName(beanPath).newInstance();//把key和value存入容器中beans.put(key,value);}}catch(Exception e){throw new ExceptionInInitializerError("初始化properties失败！");}}/*** 根据bean的名称获取对象* @param beanName* @return*/public static Object getBean(String beanName){return beans.get(beanName);}/*** 根据Bean的名称获取bean对象* @param beanName* @returnpublic static Object getBean(String beanName){Object bean = null;try {String beanPath = props.getProperty(beanName);
//            System.out.println(beanPath);bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象}catch (Exception e){e.printStackTrace();}return bean;}*/
}

客户端：模拟表现层

/*** 模拟一个表现层，用于调用业务层*/
public class Client {public static void main(String[] args) {//--------BeanFactory----------IAccountService as  = (IAccountService)BeanFactory.getBean("accountService");System.out.println(as);}
}

三、spring中的IOC

IOC：控制反转，解决程序间的依赖，通过new创建对象是自主控制的，现在将对象的创建交由容器了，所以控制权转移了

1. spring中基于XML的IOC环境搭建

pom.xml

<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency>

bean.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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--把对象的创建交给spring来管理--><bean id="accountService" class="com.weilai.service.impl.AccountServiceImpl"></bean><bean id="accountDao" class="com.weilai.dao.impl.AccountDaoImpl"></bean>
</beans>

Client.java

/*** 模拟一个表现层，用于调用业务层*/
public class Client {/*** 获取spring的Ioc核心容器，并根据id获取对象** ApplicationContext的三个常用实现类：*      ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)*      FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）**      AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容。** 核心容器的两个接口引发出的问题：*  ApplicationContext:     单例对象适用              采用此接口*      它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。**  BeanFactory:            多例对象使用*      它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。* @param args*/public static void main(String[] args) {//1.获取核心容器对象ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//        ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\zhy\\Desktop\\bean.xml");//2.根据id获取Bean对象IAccountService as  = (IAccountService)ac.getBean("accountService");IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);System.out.println(as);System.out.println(adao);as.saveAccount();//--------BeanFactory----------
//        Resource resource = new ClassPathResource("bean.xml");
//        BeanFactory factory = new XmlBeanFactory(resource);
//        IAccountService as  = (IAccountService)factory.getBean("accountService");
//        System.out.println(as);}
}

2. spring中bean的细节

模拟工厂类

/*** 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）*/
public class InstanceFactory {public IAccountService getAccountService(){return new AccountServiceImpl();}
}public class StaticFactory {public static IAccountService getAccountService(){return new AccountServiceImpl();}
}

bean.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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--把对象的创建交给spring来管理--><!--spring对bean的管理细节1.创建bean的三种方式2.bean对象的作用范围3.bean对象的生命周期--><!--创建Bean的三种方式 --><!-- 第一种方式：使用默认构造函数创建。在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。<bean id="accountService" class="com.weilai.service.impl.AccountServiceImpl"></bean>--><!-- 第二种方式： 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）<bean id="instanceFactory" class="com.weilai.factory.InstanceFactory"></bean><bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>--><!-- 第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)<bean id="accountService" class="com.weilai.factory.StaticFactory" factory-method="getAccountService"></bean>--><!-- bean的作用范围调整bean标签的scope属性：作用：用于指定bean的作用范围取值： 常用的就是单例的和多例的singleton：单例的（默认值）prototype：多例的request：作用于web应用的请求范围session：作用于web应用的会话范围global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session<bean id="accountService" class="com.weilai.service.impl.AccountServiceImpl" scope="prototype"></bean>--><!-- bean对象的生命周期单例对象出生：当容器创建时对象出生活着：只要容器还在，对象一直活着死亡：容器销毁，对象消亡总结：单例对象的生命周期和容器相同多例对象出生：当我们使用对象时spring框架为我们创建活着：对象只要是在使用过程中就一直活着。死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收--><bean id="accountService" class="com.weilai.service.impl.AccountServiceImpl"scope="prototype" init-method="init" destroy-method="destroy"></bean>
</beans>

Client.java

/*** 模拟一个表现层，用于调用业务层*/
public class Client {/**** @param args*/public static void main(String[] args) {//1.获取核心容器对象
//        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.根据id获取Bean对象IAccountService as  = (IAccountService)ac.getBean("accountService");as.saveAccount();//手动关闭容器ac.close();}
}

四、依赖注入（Dependency Injection）