spring知识总结1

最新推荐文章于 2024-05-30 09:19:51 发布

qq_38769290

最新推荐文章于 2024-05-30 09:19:51 发布

阅读量172

点赞数

文章标签： spring java

本文链接：https://blog.csdn.net/qq_38769290/article/details/105570245

版权

Spring知识总结1

1、程序的耦合

我们在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的。
请看下面的示例代码：
/**
* 账户的业务层实现类
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
*/
public class AccountServiceImpl implements IAccountService {
	private IAccountDao accountDao = new AccountDaoImpl();
}
上面的代码表示：
业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。
//如果此时没有持久层实现类，编译将不能通过。
这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。

再比如：
早期我们的 JDBC 操作，注册驱动时，我们为什么不使用 DriverManager 的 register 方法，而是采
用 Class.forName 的方式？
public class JdbcDemo1 {
/**
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
//1.注册驱动
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");
//2.获取连接
//3.获取预处理 sql 语句对象
//4.获取结果集
//5.遍历结果集
} }
原因就是：
我们的类依赖了数据库的具体驱动类（MySQL），如果这时候更换了数据库品牌（比如 Oracle），需要
修改源码来重新数据库驱动。这显然不是我们想要的。
2.1.2 解决程序耦合的思路
当是我们讲解 jdbc 时，是通过反射来注册驱动的，代码如下：
Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串
此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译（运
行就不要想了，没有驱动不可能运行成功的）。
同时，也产生了一个新的问题，mysql 驱动的全限定类名字符串是在 java 类中写死的，一旦要改还是要修改
源码。
解决这个问题也很简单，使用配置文件配置。

2、IOC解耦

实际开发中：
 	//应该做到：编译期不依赖，运行时才依赖。
	解耦的思路：
		第一步：使用反射来创建对象，而避免使用new关键字。
		第二步：通过读取配置文件来获取要创建的对象全限定类名

2.1 工厂模式解耦

/**
 * 一个创建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>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象,Class.forName(str)返回的是一个Class对象
              	//这里的newInstance得到的是根据全类名反射创建出来的对象
                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.properties
accountService=com.itheima.service.impl.AccountServiceImpl
accountDao=com.itheima.dao.impl.AccountDaoImpl

说明：用accountService和accountDao作为相应的全类名的key,存入properties配置文件中，然后在BeanFactory类里面将accountService和accountDao作为key，各自的全类名反射创建出来的对象作为value存入名为beans的Map对象中。

//此处省略sevice和dao的接口以及实现方法
/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {

    public static void main(String[] args) {
        //IAccountService as = new AccountServiceImpl();
        for(int i=0;i<5;i++) {
          	//这里就算没有IAccountService的实现类，编译也是可以通过的，这就体现了解耦思想
            IAccountService as = (IAccountService) BeanFactory.getBean("accountService");
            System.out.println(as);
            as.saveAccount();
        }

    }
}

2.2 Spring IOC核心容器

IOC(Inversion of Control)，控制反转，把创建对象的权利交给框架，是框架的重要特征。它包括依赖注（Dependency Injection）和依赖查找（Dependency Lookup）

2.2.1 BeanFactory和ApplicaionContext的区别

BeanFactory 才是 Spring 容器中的顶层接口。

ApplicationContext 是它的子接口。

BeanFactory 和 ApplicationContext 的区别：

创建对象的时间点不一样。

ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。

BeanFactory：什么使用什么时候创建对象。

spring工厂中类的结构图
在这里插入图片描述

/**
 * 模拟一个表现层，用于调用业务层
 */
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");
      	 //XmlBeanFactory过时了
//        BeanFactory factory = new XmlBeanFactory(resource);
//        IAccountService as  = (IAccountService)factory.getBean("accountService");
//        System.out.println(as);
    }
}

<!--放在resources目录下的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/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
</beans>

//spring要用到的依赖
<dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>5.0.2.RELEASE</version>
</dependency>

在这里插入图片描述

2.2.2 IOC中bean标签和管理对象细节

2.2.2.1 bean标签

作用：
用于配置对象让 spring 来创建的。
//默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性：
id：给对象在容器中提供一个唯一标识。用于获取对象。
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
scope：指定对象的作用范围。
	* singleton :默认值，单例的.
	* prototype :多例的.
	* request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
	* session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
	* global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么
		globalSession 相当于 session.
init-method：指定类中的初始化方法名称。
destroy-method：指定类中销毁方法名称。

2.2.2.2 bean的作用范围和生命周期

单例对象：scope="singleton"
	一个应用只有一个对象的实例。它的作用范围就是整个应用。
	生命周期：
		对象出生：当应用加载，创建容器时，对象就被创建了。
		对象活着：只要容器在，对象一直活着。
		对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope="prototype"
	每次访问对象时，都会重新创建对象实例。
	生命周期：
		对象出生：当使用对象时，创建新的对象实例。
		对象活着：只要对象在使用中，就一直活着。
		对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

2.2.2.3 实例化bean的三种方式

第一种方式：
使用默认构造函数创建。在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

第二种方式：
spring 管理静态工厂-使用静态工厂的方法创建对象
/**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory {
	public static IAccountService createAccountService(){
		return new AccountServiceImpl();
	} 
}
此种方式是:
使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
	id 属性：指定 bean 的 id，用于从容器中获取
	class 属性：指定静态工厂的全限定类名
	factory-method 属性：指定生产对象的静态方法
<bean id="accountService" class="com.itheima.factory.StaticFactory" 
  factory-method="createAccountService"></bean>
  
第三种方式：
spring 管理实例工厂-使用实例工厂的方法创建对象
/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
	public IAccountService createAccountService(){
		return new AccountServiceImpl();
	} 
}
此种方式是：
	先把工厂的创建交给 spring 来管理。
	然后在使用工厂的 bean 来调用里面的方法
	factory-bean 属性：用于指定实例工厂 bean 的 id。
	factory-method 属性：用于指定实例工厂中创建对象的方法。
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean> 
<bean id="accountService" factory-bean="instancFactory" 
  factory-method="createAccountService"></bean>

2.2.3 Spring的依赖注入

2.3.3.1 依赖注入的概念

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

2.3.3.2 构造函数注入

顾名思义，就是使用类中的构造函数，给成员变量赋值。//类似于用带参构造函数创建对象
//注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。
具体代码如下：

public class AccountServiceImpl implements IAccountService {
	private String name;
	private Integer age;
	private Date birthday;
	
	public AccountServiceImpl(String name, Integer age, Date birthday) {
		this.name = name;
		this.age = age;
		this.birthday = birthday; 
	}
	
	@Override
	public void saveAccount() {
		System.out.println(name+","+age+","+birthday);
	} 
}

使用构造函数的方式，给 service 中的属性传值
要求：
//类中需要提供一个对应参数列表的构造函数。
涉及的标签：
	constructor-arg
属性：
	index:指定参数在构造函数参数列表的索引位置
	type:指定参数在构造函数中的数据类型
	name:指定参数在构造函数中的名称 用这个找给谁赋值
=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
	value:它能赋的值是//基本数据类型和 String 类型
	ref:它能赋的值是其他 bean 类型，也就是说，//必须得是在配置文件中配置过的 bean
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"> 
	<constructor-arg name="name" value="张三"></constructor-arg> 
	<constructor-arg name="age" value="18"></constructor-arg> 
	<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean> 
<bean id="now" class="java.util.Date"></bean>

2.3.3.3 set方法注入

顾名思义，就是在类中提供需要注入成员的 set 方法。具体代码如下：
//不需要自己去调用set方法去给对象的属性赋值，而是用配置的方式
public class AccountServiceImpl implements IAccountService {
	private String name;
	private Integer age;
	private Date birthday;
	public void setName(String name) {
		this.name = name; 
	}
	public void setAge(Integer age) {
		this.age = age; 
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday; 
	}
	@Override
	public void saveAccount() {
		System.out.println(name+","+age+","+birthday);
	} 
}
通过配置文件给 bean 中的属性传值：使用 set 方法的方式
涉及的标签：
	property
属性：
	name：找的是类中 set 方法后面的部分
	ref：给属性赋值是其他 bean 类型的
	value：给属性赋值是基本数据类型和 string 类型的
实际开发中，此种方式用的较多。
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"> 
	<property name="name" value="test"></property> 
	<property name="age" value="21"></property> 
	<property name="birthday" ref="now"></property>
</bean> 
<bean id="now" class="java.util.Date"></bean>

2.3.3.4 注入集合属性

顾名思义，就是给类中的集合成员传值，它用的也是//set方法注入的方式，只不过变量的数据类型都是集合。
我们这里介绍注入//数组，List,Set,Map,Properties。
具体代码如下：

public class AccountServiceImpl implements IAccountService {
	private String[] myStrs;
	private List<String> myList;
	private Set<String> mySet;
	private Map<String,String> myMap;
	private Properties myProps;
	
	public void setMyStrs(String[] myStrs) {
		this.myStrs = myStrs;
	}
	public void setMyList(List<String> myList) {
		this.myList = myList; 
	}
	public void setMySet(Set<String> mySet) {
		this.mySet = mySet; 
	}
	public void setMyMap(Map<String, String> myMap) {
		this.myMap = myMap; 
	}
	public void setMyProps(Properties myProps) {
		this.myProps = myProps; 
	}
	@Override
	public void saveAccount() {
		System.out.println(Arrays.toString(myStrs));
		System.out.println(myList);
		System.out.println(mySet);
		System.out.println(myMap);
		System.out.println(myProps);
	} 
}
注入集合数据
	List 结构的：
		array,list,set
	Map 结构的
		map,entry,props,prop
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
//在注入集合数据时，只要结构相同，标签可以互换
<!-- 给数组注入数据 --> 
	<property name="myStrs"> 
		<set>
			<value>AAA</value> 
			<value>BBB</value> 
			<value>CCC</value>
		</set>
	</property>
<!-- 注入 list 集合数据 --> 
	<property name="myList"> 
		<array> 
			<value>AAA</value> 
			<value>BBB</value> 
			<value>CCC</value>
		</array>
	</property>
<!-- 注入 set 集合数据 --> 
	<property name="mySet"> 
		<list>
			<value>AAA</value> 
			<value>BBB</value> 
			<value>CCC</value>
		</list>
	</property>
<!-- 注入 Map 数据 --> 
	<property name="myMap"> 
		<props> 
			<prop key="testA">aaa</prop> 
			<prop key="testB">bbb</prop>
		</props>
	</property>
<!-- 注入 properties 数据 -->
	<property name="myProps"> 
		<map>
			<entry key="testA" value="aaa"></entry> 
			<entry key="testB"> <value>bbb</value></entry>
		</map>
	</property>
</bean>

qq_38769290

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring知识总结1

Spring知识总结11、程序的耦合我们在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的。请看下面的示例代码：/*** 账户的业务层实现类* @author 黑马程序员* @Company http://www.ithiema.com* @Version 1.0*/public class AccountServiceImpl implements IAcc...
复制链接

扫一扫