百知教育 — Spring系列课程 — 工厂


第一章 引言

1. EJB存在的问题

2. 什么是Spring
Spring是一个轻量级的JavaEE解决方案,整合众多优秀的设计模式
  • 轻量级

    1. 对于运行环境是没有额外要求的
    开源 tomcat resion jetty
    收费 weblogic websphere
    2. 代码移植性高
    不需要实现额外接口
  • JavaEE的解决方案

  • 整合设计模式
1. 工厂
2. 代理
3. 模板
4. 策略
3. 设计模式
1. 广义概念
面向对象设计中,解决特定问题的经典代码
2. 狭义概念
GOF4人帮定义的23种设计模式:工厂、适配器、装饰器、门面、代理、模板...
4. 工厂设计模式
4.1 什么是工厂设计模式
1. 概念:通过工厂类,创建对象
User user = new User();
UserDAO userDAO = new UserDAOImpl();
2. 好处:解耦合
耦合:指定是代码间的强关联关系,一方的改变会影响到另一方
问题:不利于代码维护
简单:把接口的实现类,硬编码在程序中
UserService userService = new UserServiceImpl();
4.2 简单工厂的设计
package com.baizhiedu.basic;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties; public class BeanFactory {
private static Properties env = new Properties(); static{
try {
//第一步 获得IO输入流
InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
//第二步 文件内容 封装 Properties集合中 key = userService value = com.baizhixx.UserServiceImpl
env.load(inputStream); inputStream.close();
} catch (IOException e) {
e.printStackTrace();
} } /*
对象的创建方式:
1. 直接调用构造方法 创建对象 UserService userService = new UserServiceImpl();
2. 通过反射的形式 创建对象 解耦合
Class clazz = Class.forName("com.baizhiedu.basic.UserServiceImpl");
UserService userService = (UserService)clazz.newInstance();
*/
public static UserService getUserService() { UserService userService = null;
try {
//com.baizhiedu.basic.UserServiceImpl
Class clazz = Class.forName(env.getProperty("userService"));
userService = (UserService) clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} return userService; } public static UserDAO getUserDAO(){ UserDAO userDAO = null;
try {
Class clazz = Class.forName(env.getProperty("userDAO"));
userDAO = (UserDAO) clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} return userDAO; }
}
4.3 通用工厂的设计
  • 问题

    简单工厂会存在大量的代码冗余

  • 通用工厂的代码

    创建一切想要的对象
    public class BeanFactory{ public static Object getBean(String key){
    Object ret = null;
    try {
    Class clazz = Class.forName(env.getProperty(key));
    ret = clazz.newInstance();
    } catch (Exception e) {
    e.printStackTrace();
    }
    return ret;
    } }
4.4 通用工厂的使用方式
1. 定义类型 (类)
2. 通过配置文件的配置告知工厂(applicationContext.properties)
key = value
3. 通过工厂获得类的对象
Object ret = BeanFactory.getBean("key")
5.总结
Spring本质:工厂 ApplicationContext (applicationContext.xml)

第二章、第一个Spring程序

1. 软件版本
1. JDK1.8+
2. Maven3.5+
3. IDEA2018+
4. SpringFramework 5.1.4
官方网站 www.spring.io
2. 环境搭建
  • Spring的jar包

    #设置pom 依赖
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.4.RELEASE</version>
    </dependency>
  • Spring的配置文件

    1. 配置文件的放置位置:任意位置 没有硬性要求
    2. 配置文件的命名 :没有硬性要求 建议:applicationContext.xml 思考:日后应用Spring框架时,需要进行配置文件路径的设置。

3. Spring的核心API
  • ApplicationContext

    作用:Spring提供的ApplicationContext这个工厂,用于对象的创建
    好处:解耦合
    • ApplicationContext接口类型

      接口:屏蔽实现的差异
      非web环境 : ClassPathXmlApplicationContext (main junit)
      web环境 : XmlWebApplicationContext

    • 重量级资源

      ApplicationContext工厂的对象占用大量内存。
      不会频繁的创建对象 : 一个应用只会创建一个工厂对象。
      ApplicationContext工厂:一定是线程安全的(多线程并发访问)
4. 程序开发
1. 创建类型
2. 配置文件的配置 applicationContext.xml
<bean id="person" class="com.baizhiedu.basic.Person"/>
3. 通过工厂类,获得对象
ApplicationContext
|- ClassPathXmlApplicationContext
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
Person person = (Person)ctx.getBean("person");
5. 细节分析
  • 名词解释

    Spring工厂创建的对象,叫做bean或者组件(componet)
  • Spring工厂的相关的方法

    //通过这种方式获得对象,就不需要强制类型转换
    Person person = ctx.getBean("person", Person.class);
    System.out.println("person = " + person); //当前Spring的配置文件中 只能有一个<bean class是Person类型
    Person person = ctx.getBean(Person.class);
    System.out.println("person = " + person); //获取的是 Spring工厂配置文件中所有bean标签的id值 person person1
    String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
    System.out.println("beanDefinitionName = " + beanDefinitionName);
    } //根据类型获得Spring配置文件中对应的id值
    String[] beanNamesForType = ctx.getBeanNamesForType(Person.class);
    for (String id : beanNamesForType) {
    System.out.println("id = " + id);
    } //用于判断是否存在指定id值得bean
    if (ctx.containsBeanDefinition("a")) {
    System.out.println("true = " + true);
    }else{
    System.out.println("false = " + false);
    } //用于判断是否存在指定id值得bean
    if (ctx.containsBean("person")) {
    System.out.println("true = " + true);
    }else{
    System.out.println("false = " + false);
    }
  • 配置文件中需要注意的细节

    1. 只配置class属性
    <bean class="com.baizhiedu.basic.Person"/>
    a) 上述这种配置 有没有id值 com.baizhiedu.basic.Person#0
    b) 应用场景: 如果这个bean只需要使用一次,那么就可以省略id值
    如果这个bean会使用多次,或者被其他bean引用则需要设置id值 2. name属性
    作用:用于在Spring的配置文件中,为bean对象定义别名(小名)
    相同:
    1. ctx.getBean("id|name")-->object
    2. <bean id="" class=""
    等效
    <bean name="" class=""
    区别:
    1. 别名可以定义多个,但是id属性只能有一个值
    2. XML的id属性的值,命名要求:必须以字母开头,字母 数字 下划线 连字符 不能以特殊字符开头 /person
    name属性的值,命名没有要求 /person
    name属性会应用在特殊命名的场景下:/person (spring+struts1) XML发展到了今天:ID属性的限制,不存在 /person
    3. 代码
    //用于判断是否存在指定id值得bean,不能判断name值
    if (ctx.containsBeanDefinition("person")) {
    System.out.println("true = " + true);
    }else{
    System.out.println("false = " + false);
    } //用于判断是否存在指定id值得bean,也可以判断name值
    if (ctx.containsBean("p")) {
    System.out.println("true = " + true);
    }else{
    System.out.println("false = " + false);
    }
6. Spring工厂的底层实现原理(简易版)

Spring工厂是可以调用对象私有的构造方法创建对象

7. 思考
问题:未来在开发过程中,是不是所有的对象,都会交给Spring工厂来创建呢?
回答:理论上 是的,但是有特例 :实体对象(entity)是不会交给Spring创建,它是由持久层框架进行创建。

第三章、Spring5.x与日志框架的整合

Spring与日志框架进行整合,日志框架就可以在控制台中,输出Spring框架运行过程中的一些重要的信息。
好处:便于了解Spring框架的运行过程,利于程序的调试
  • Spring如何整合日志框架

    默认
    Spring1.2.3早期都是于commons-logging.jar
    Spring5.x默认整合的日志框架 logback log4j2 Spring5.x整合log4j
    1. 引入log4j jar包
    2. 引入log4.properties配置文件
    • pom

      <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.25</version>
      </dependency> <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
      </dependency>
    • log4j.properties

      # resources文件夹根目录下
      ### 配置根
      log4j.rootLogger = debug,console ### 日志输出到控制台显示
      log4j.appender.console=org.apache.log4j.ConsoleAppender
      log4j.appender.console.Target=System.out
      log4j.appender.console.layout=org.apache.log4j.PatternLayout
      log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

第四章、注入(Injection)

1. 什么是注入
通过Spring工厂及配置文件,为所创建对象的成员变量赋值
1.1 为什么需要注入

通过编码的方式,为成员变量进行赋值,存在耦合

1.2 如何进行注入[开发步骤]
  • 类的成员变量提供set get方法

  • 配置spring的配置文件

     <bean id="person" class="com.baizhiedu.basic.Person">
    <property name="id">
    <value>10</value>
    </property>
    <property name="name">
    <value>xiaojr</value>
    </property>
    </bean>
1.3 注入好处
解耦合
2. Spring注入的原理分析(简易版)

Spring通过底层调用对象属性对应的set方法,完成成员变量的赋值,这种方式我们也称之为set注入

第五章、Set注入详解

针对于不同类型的成员变量,在<property>标签,需要嵌套其他标签

<property>
xxxxx
</property>

1. JDK内置类型
1.1 String+8种基本类型
<value>suns</value>
1.2 数组
<list>
<value>suns@zparkhr.com.cn</value>
<value>liucy@zparkhr.com.cn</value>
<value>chenyn@zparkhr.com.cn</value>
</list>
1.3 Set集合
<set>
<value>11111</value>
<value>112222</value>
</set> <set>
<ref bean
<set
</set>
1.4 List集合
<list>
<value>11111</value>
<value>2222</value>
</list> <list>
<ref bean
<set
</list>
1.5 Map集合
注意: map -- entry  -- key有特定的标签  <key></key>
值根据对应类型选择对应类型的标签
<map>
<entry>
<key><value>suns</value></key>
<value>3434334343</value>
</entry>
<entry>
<key><value>chenyn</value></key>
<ref bean
</entry>
</map>
1.6 Properites
Properties类型 特殊的Map key=String value=String
<props>
<prop key="key1">value1</prop>
<prop key="key2">value2</prop>
</props>
1.7 复杂的JDK类型 (Date)
需要程序员自定义类型转换器,处理。
2. 用户自定义类型
2.1 第一种方式
  • 为成员变量提供set get方法

  • 配置文件中进行注入(赋值)

    <bean id="userService" class="xxxx.UserServiceImpl">
    <property name="userDAO">
    <bean class="xxx.UserDAOImpl"/>
    </property>
    </bean>
2.2 第二种方式
  • 第一种赋值方式存在的问题

    1. 配置文件代码冗余
    2. 被注入的对象(UserDAO),多次创建,浪费(JVM)内存资源
  • 为成员变量提供set get方法

  • 配置文件中进行配置

    <bean id="userDAO" class="xxx.UserDAOImpl"/>
    
    <bean id="userService" class="xxx.UserServiceImpl">
    <property name="userDAO">
    <ref bean="userDAO"/>
    </property>
    </bean> #Spring4.x 废除了 <ref local=""/> 基本等效 <ref bean=""/>
    3. Set注入的简化写法
    3.1 基于属性简化
    JDK类型注入
    <property name="name">
    <value>suns</value>
    </property> <property name="name" value="suns"/>
    注意:value属性 只能简化 8种基本类型+String 注入标签 用户自定义类型
    <property name="userDAO">
    <ref bean="userDAO"/>
    </property> <property name="userDAO" ref="userDAO"/>
    3.2 基于p命名空间简化
    JDK类型注入
    <bean id="person" class="xxxx.Person">
    <property name="name">
    <value>suns</value>
    </property>
    </bean> <bean id="person" class="xxx.Person" p:name="suns"/>
    注意:value属性 只能简化 8种基本类型+String 注入标签 用户自定义类型
    <bean id="userService" class="xx.UserServiceImpl">
    <property name="userDAO">
    <ref bean="userDAO"/>
    </property>
    </bean> <bean id="userService" class="xxx.UserServiceImpl" p:userDAO-ref="userDAO"/>

第六章、构造注入

注入:通过Spring的配置文件,为成员变量赋值
Set注入:Spring调用Set方法 通过配置文件 为成员变量赋值
构造注入:Spring调用构造方法 通过配置文件 为成员变量赋值
1. 开发步骤
  • 提供有参构造方法

    public class Customer implements Serializable {
    private String name;
    private int age; public Customer(String name, int age) {
    this.name = name;
    this.age = age;
    }
    }
  • Spring的配置文件

    <bean id="customer" class="com.baizhiedu.basic.constructer.Customer">
    <constructor-arg>
    <value>suns</value>
    </constructor-arg>
    <constructor-arg>
    <value>102</value>
    </constructor-arg>
    </bean>
2. 构造方法重载
2.1 参数个数不同时
通过控制<constructor-arg>标签的数量进行区分
2.1 构造参数个数相同时
通过在标签引入 type属性 进行类型的区分 <constructor-arg type="">
3. 注入的总结
未来的实战中,应用set注入还是构造注入?
答案:set注入更多
1. 构造注入麻烦 (重载)
2. Spring框架底层 大量应用了 set注入

第七章、反转控制 与 依赖注入

1. 反转(转移)控制(IOC Inverse of Control)
控制:对于成员变量赋值的控制权
反转控制:把对于成员变量赋值的控制权,从代码中反转(转移)到Spring工厂和配置文件中完成
好处:解耦合
底层实现:工厂设计模式

2. 依赖注入 (Dependency Injection DI)
注入:通过Spring的工厂及配置文件,为对象(bean,组件)的成员变量赋值

依赖注入:当一个类需要另一个类时,就意味着依赖,一旦出现依赖,就可以把另一个类作为本类的成员变量,最终通过Spring配置文件进行注入(赋值)。
好处:解耦合

第八章、Spring工厂创建复杂对象

1. 什么是复杂对象
复杂对象:指的就是不能直接通过new构造方法创建的对象
Connection
SqlSessionFactory
2. Spring工厂创建复杂对象的3种方式
2.1 FactoryBean接口
  • 开发步骤

    • 实现FactoryBean接口

    • Spring配置文件的配置

      # 如果Class中指定的类型 是FactoryBean接口的实现类,那么通过id值获得的是这个类所创建的复杂对象  Connection
      <bean id="conn" class="com.baizhiedu.factorybean.ConnectionFactoryBean"/>
  • 细节

    • 如果就想获得FactoryBean类型的对象 ctx.getBean("&conn")

      获得就是ConnectionFactoryBean对象

    • isSingleton方法

      返回 true 只会创建一个复杂对象

      返回 false 每一次都会创建新的对象

      问题:根据这个对象的特点 ,决定是返回true (SqlSessionFactory) 还是 false (Connection)

    • mysql高版本连接创建时,需要制定SSL证书,解决问题的方式

      url = "jdbc:mysql://localhost:3306/suns?useSSL=false"
    • 依赖注入的体会(DI)

      把ConnectionFactoryBean中依赖的4个字符串信息 ,进行配置文件的注入
      好处:解耦合
      <bean id="conn" class="com.baizhiedu.factorybean.ConnectionFactoryBean">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/suns?useSSL=false"/>
      <property name="username" value="root"/>
      <property name="password" value="123456"/>
      </bean>
  • FactoryBean的实现原理[简易版]

    接口回调
    1. 为什么Spring规定FactoryBean接口 实现 并且 getObject()?
    2. ctx.getBean("conn") 获得是复杂对象 Connection 而没有 获得 ConnectionFactoryBean(&) Spring内部运行流程
    1. 通过conn获得 ConnectionFactoryBean类的对象 ,进而通过instanceof 判断出是FactoryBean接口的实现类
    2. Spring按照规定 getObject() ---> Connection
    3. 返回Connection

  • FactoryBean总结

    Spring中用于创建复杂对象的一种方式,也是Spring原生提供的,后续讲解Spring整合其他框架,大量应用FactoryBean
2.2 实例工厂
1. 避免Spring框架的侵入
2. 整合遗留系统
  • 开发步骤
 <bean id="connFactory" class="com.baizhiedu.factorybean.ConnectionFactory"></bean>

 <bean id="conn"  factory-bean="connFactory" factory-method="getConnection"/>
2.3 静态工厂
  • 开发步骤

    <bean id="conn" class="com.baizhiedu.factorybean.StaticConnectionFactory" factory-method="getConnection"/>
3. Spring工厂创建对象的总结

第九章、控制Spring工厂创建对象的次数

1. 如何控制简单对象的创建次数
<bean id="account" scope="singleton|prototype" class="xxxx.Account"/>
sigleton:只会创建一次简单对象 默认值
prototype:每一次都会创建新的对象
2. 如何控制复杂对象的创建次数
FactoryBean{
isSingleton(){
return true 只会创建一次
return false 每一次都会创建新的
} }
如没有isSingleton方法 还是通过scope属性 进行对象创建次数的控制
3. 为什么要控制对象的创建次数?
好处:节省不别要的内存浪费
  • 什么样的对象只创建一次?

    1. SqlSessionFactory
    2. DAO
    3. Service
  • 什么样的对象 每一次都要创建新的?

    1. Connection
    2. SqlSession | Session
    3. Struts2 Action

Spring一套全通—工厂的更多相关文章

  1. Spring一套全通4—持久层整合

    百知教育 - Spring系列课程 - 持久层整合 第一章.持久层整合 1.Spring框架为什么要与持久层技术进行整合 1. JavaEE开发需要持久层进行数据库的访问操作. 2. JDBC Hib ...

  2. 为caffe添加最简单的全通层AllPassLayer

    参考赵永科的博客,这里我们实现一个新 Layer,名称为 AllPassLayer,顾名思义就是全通 Layer,“全通”借鉴于信号处理中的全通滤波器,将信号无失真地从输入转到输出. 虽然这个 Lay ...

  3. 套接字工厂——ServerSocketFactory

    接收器Acceptor在接收连接的过程中,根据不同的使用场合可能需要不同的安全级别,例如在支付相关的交易就必须对信息加密后再发送,这其中还涉及到密钥协商的过程,而在另外一些普通场合则无需对报文加密.反 ...

  4. Spring学习记录(九)---通过工厂方法配置bean

    1. 使用静态工厂方法创建Bean,用到一个工厂类 例子:一个Car类,有brand和price属性. package com.guigu.spring.factory; public class C ...

  5. (精简)Spring框架的IoC(替代工厂类实现方法)和AOP(定义规则,约定大于配置)

    Spring的核心框架主要包含两个技术,分别用来处理工厂类,以及事务处理和连接管理的. 两大核心概念 1)  IoC:控制反转,在现在的开发中,如果想建立对象并设置属性,是需要先new对象,再通过se ...

  6. FKP,一套全栈框架,基于react、webpack、koa1、babel

    FKP-REST是一套前后端分离,基于javascript的全栈实现,基于node的高性能,易部署性及javascript前后端语言的一致性,学习成本,时间成本及项目快速启动等等方面,FKP都是一种不 ...

  7. Spring RESTful + Redis全注解实现恶意登录保护机制

    好久没更博了... 最近看了个真正全注解实现的 SpringMVC 博客,感觉很不错,终于可以彻底丢弃 web.xml 了.其实这玩意也是老东西了,丢弃 web.xml,是基于 5.6年前发布的 Se ...

  8. 2017年3月28日15:59:16 终于明白spring这套鬼东西是怎么玩的了

    先说重点,新东家公司的项目框架没有一样是我之前用过的,首先pm和我说的是一套微服务的概念,微服务不同于传统的功能模块实现,他将服务松散化分不到各个系统之间,这样也是实现分散压力的一种. 微服务是由sp ...

  9. Spring 反射注入+全注解注入

    Spring IoC容器会先把所有的Bean都进行实例化,不管是要用到的火鼠用不到的,如果你想暂时不进行Bean的实例化,要用到属性lazy-init="true". Spring ...

随机推荐

  1. Jmeter系列(7)- 分析源码,创建下单、用户注销接口请求

    源码分析 下单 用户注销 创建请求 下单 用户注销 请求调整 将信息头管理器从[02.浏览订单]请求中抽出来就变成公用的.[03,04]请求不需要单独再加信息头管理器 DeBug取样器 添加DeBug ...

  2. delete,drop,truncate 区别

    今天看到一篇关于delete.drop.truncate区别的文章,认为写得非常好,转过来. 打比方很形象. delete,drop,truncate 都有删除表的作用,区别在于: 1.delete ...

  3. session入库

    #存储session的数据表示列结构,可作为参考#创建数据库(可选)CREATE DATABASE session;#使用创建的数据库(可选)USE session;#创建存储session的数据表( ...

  4. 防刷功能的实现(thinkphp5)

    $seconds = '3'; //时间段[秒] $refresh = '3';//最大次数 $cur_time = time(); if(Session::get('refresh_times')) ...

  5. AT2567-[ARC074C]RGB Sequence【dp】

    正题 题目链接:https://www.luogu.com.cn/problem/AT2567 题目大意 长度为\(n\)的包含三种颜色\(RGB\)的序列,\(m\)个限制\([l,r,k]\)表示 ...

  6. 深入浅出WPF-07.Property(属性)

    依赖属性 1)字段与属性:字段被封装在实例中,要么能够被外界访问(非Private),要么不能够被外界访问(Private).但是我们直接把数据暴露给外界的做法不安全,容易把错误的数据写入字段.于是我 ...

  7. 四、mybatis动态sql

    # 前言前面mysql都是通过静态sql进行查询的,但是如果业务复杂的时候,我们会遇到引号问题,或者多一个空格,这就使得sql代码编写错误了,所以为了解决这个问题,我们有了动态sql. Mybatis ...

  8. Fiddler抓包一键生成代码

    首先我们的需求场景是 用Fiddler抓到某个接口调用后,用代码来模拟调用,一般我们写代码会有3个步骤: 1设置http请求相关的参数:header,method,url,cookie等 2设置pos ...

  9. 【Azure Developer】如何验证 Azure AD的JWT Token (JSON Web 令牌)?

    问题描述 使用微软Azure AD,对授权进行管理.通过所注册应用的OAuth API(https://login.chinacloudapi.cn/{TENANT ID}/oauth2/v2.0/t ...

  10. WEB安全指南

    说明:本文是Mozilla Web应用部署文档,对运维或者后端开发团队的部署行为进行指导.该部署安全规范内容充实,对于部署有很大意义.同时也涉及到了许多web前端应用安全的基本知识,如CSP, TOK ...