JAVAEE框架整合技术之Spring01-IOC教程

Posted teayear

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JAVAEE框架整合技术之Spring01-IOC教程相关的知识,希望对你有一定的参考价值。

Spring

一.Spring概述

1.什么是Spring

Spring是分层的JavaEE应用 full-stack(全栈) 轻量级开源框架。
Spring的核心是IOC(Inverse Of Control:控制反转)和 AOP(Aspect Oriented Programming:面向切面编程)
Spring一个全栈应用框架, 提供了表现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多应用技术
Spring还能整合开源世界众多著名的第三方框架和类库,逐渐成为使用最多的 Java EE 企业应用开源框架 
==Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术。

2.为什么要学习Spring

  • 最大程度的简化了开发
    	Spring是一个非常优秀的java框架,其目标是为了简化java企业级开发,Spring出来已经二十几年了,这期间也一直围绕着这个目标在进行,像后面需要学习的Springmvc、Springboot、Springcloud,这些技术也都是围绕着简化开发的目标在努力,到目前为止已经做的足够好了,可以说Spring除不能帮助我们实现业务逻辑代码之外,其他的事情Spring都尽量去帮我们简化,使用Spring可以帮助我们节约大量开发时间。
    
    	不使用Spring的情况下,开发一个项目可能需要2个月,用了Spring可能1个月都不需要,你说这样的技术你想学么?
    
  • 大量公司使用
    目前99%的公司使用了Spring,可以去各大招聘网站看一下,Spring算是必备技能,所以一定要掌握。
    
  • 顶尖的源代码
    Spring框架源码设计非常优秀,在java开源项目中可以说是顶级的,目前为止还未发现比Spring更优秀的开源项目,所以想提升代码能力的,强烈建议多看看Spring的源码;关于提升代码能力的,还可以去看一下jdk的源码,也是非常棒的,里面有很多大师的杰作。
    

3.Spring的发展历程

	要谈Spring的历史,就要先谈J2EE。J2EE应用程序的广泛实现是在1999年和2000年开始的,它的出现带来了诸如事务管理之类的核心中间层概念的标准化,但是在实践中并没有获得绝对的成功,因为开发效率,开发难度和实际的性能都令人失望。

​	曾经使用过EJB开发JAVAEE应用的人,一定知道,在EJB开始的学习和应用非常的艰苦,很多东西都不能一下子就很容易的理解。EJB要严格地实现各种不同类型的接口,类似的或者重复的代码大量存在。而配置也是复杂和单调,同样使用JNDI进行对象查找的代码也是单调而枯燥。虽然有一些开发工作随着xdoclet的出现,而有所缓解,但是学习EJB的高昂代价,和极低的开发效率,极高的资源消耗,都造成了EJB的使用困难。而Spring出现的初衷就是为了解决类似的这些问题。

​	Spring的形成,最初来自Rod  Jahnson所著的一本很有影响力的书籍《Expert One-on-One J2EE Design and  Development》,就是在这本书中第一次出现了Spring的一些核心思想,该书出版于2002年。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)

4.Spring的特点及优点

Spring 除了不能帮我们写业务逻辑.其余的几乎什么什么都能帮助我们简化开发

  • 方便解耦,简化开发

    通过Spring提供的IoC容器,我们可以将对象之间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。有了Spring,用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。

  • AOP编程的支持

    通过Spring提供的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

  • 声明式事务的支持

    在Spring中,我们可以从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活地进行事务的管理,提高开发效率和质量。

  • 方便程序的测试

    可以用非容器依赖的编程方式进行几乎所有的测试工作,在Spring里,测试不再是昂贵的操作,而是随手可做的事情。例如:Spring对Junit4支持,可以通过注解方便的测试Spring程序。

  • 方便集成各种优秀框架

    Spring不排斥各种优秀的开源框架,相反,Spring可以降低各种框架的使用难度,Spring提供了对各种优秀框架(如Struts,Hibernate、Hessian、Quartz)等的直接支持。

  • 降低Java EE API的使用难度

    Spring对很多难用的Java EE API(如JDBC,JavaMail,远程调用等)提供了一个薄薄的封装层,通过Spring的简易封装,这些Java EE API的使用难度大为降低。

  • Java 源码是经典学习范例

    Spring的源码设计精妙、结构清晰、匠心独运,处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平,学习和研究Spring源码将会使你收到意想不到的效果。

一句话概括:Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器(框架)

5.Spring体系结构

二.IoC快速入门

提起Spring IoC,我们的第一反映都是控制反转,依赖注入。究其历史,如何理解这两句话的意思呢?

对于Spring IoC而言,支持的功能包含IOC Service Provider,对象创建管理和依赖注入服务。还有对象的生命周期管理,线程管理,查找服务等。

**IoC(Inverse of Control:控制反转)**是一种设计思想,就是 将原本在程序中手动创建对象的控制权,交由Spring框架来管理。 IoC 容器是 Spring 用来实现 IoC 的载体, IoC 容器实际上就是个Map(key,value),Map 中存放的是各种对象。

IoC 容器就像是一个工厂一样,当我们需要创建一个对象的时候,只需要配置好配置文件/注解即可,完全不用考虑对象是如何被创建出来的。 作者:是个程序员呀 https://www.bilibili.com/read/cv5553485/ 出处:bilibili

1.Ioc引入

  • dao层
public interface UserDao 
    public void login();

public class UserDaoImpl implements UserDao 
    @Override
    public void login() 
        System.out.println("dao层登录成功!!!");
    

  • service层
public interface UserService 
    public void login();

public class UserServiceImpl implements UserService 
    //注入业务层
    private UserDao userDao = new UserDaoImpl();

    @Override
    public void login() 
        System.out.println("业务层 登录!!!");
        //调用dao层方法
        this.userDao.login();
    

  • 测试
public class UserServiceTest 
	//测试	
    @Test
    public void login() 
        UserService userService = new UserServiceImpl();
        userService.login();
    

2.反思

【思考分析】
代码过于耦合,上层代码过度依赖于下一层代码的实现:
UserDAO userDAO = new UserDAOImpl(); 
如果要更换实现类,必须要修改原来的业务代码!
    解决方案:采用IoC(Inverse of Control,控制反转)的思想。
简单的说就是引入工厂(第三者),将原来在程序中手动创建管理的依赖的UserDAO对象,交给工厂来创建管理。在Spring框架中,这个工厂就是Spring中的工厂,因此,也可以说,将创建管理UserDAO对象的控制权被反转给了Spring框架了。


3.IoC的本质

	控制反转IoC(Inversion of Control),是一种设计思想,而不是一种新的技术。DI(依赖注入)是实现IoC的一种方法,也有人认为DI只是IoC的另一种说法(不对)。没有IoC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方。

所谓控制反转就是:获得依赖对象的方式反转
	IoC是Spring框架的核心内容,使用多种方式完美的实现了IoC,可以使用XML配置,也可以使用注解,
新版本的Spring也可以零配置实现IoC。
	Spring容器在初始化时先读取配置文件,根据配置文件或元数据创建与组织对象存入容器中,程序使用
时再从Ioc容器中取出需要的对象

IoC (Inversion of Control),即控制反转。这不是一种新的技术,而是 Spring 的一种设计思想。

在传统的程序设计,我们直接在对象内部通过 new 来创建对象,是程序主动去创建依赖对象;而在 Spring 中有专门的一个容器来创建和管理这些对象,并将对象依赖的其他对象注入到该对象中,这个容器我们一般称为 IoC 容器。

所有的类的创建、销毁都由 Spring 来控制,也就是说控制对象生存周期的不再是引用它的对象,而是 Spring。对于某个具体的对象而言,以前是它控制其他对象,现在是所有对象都被 Spring 控制,所以这叫控制反转。

DI(Dependency Injection),即依赖注入,由 Martin Fowler 提出。可以认为 IoC 和 DI 其实是同一个概念的不同角度描述。

依赖注入是指组件之间的依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能,而是为了提升组件重用的频率,并为系统搭建一个灵活、可扩展的平台。

通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。

2、bean

官方概念:在 Spring 中,构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。 bean 是一个由 Spring IoC 容器实例化,组装和管理的对象。

大白话:bean 可以认为是那些我们想注入到 Spring IoC 容器的 Java 对象实例的抽象。

我们经常会在 Service 上使用 @Service 注解,然后在要使用该 Service 的类中通过 @Autowire 注解来注入,这个 Service 就是一个 bean。在这个地方,@Service 注解相当于告诉 IoC 容器:这个类你需要帮我创建和管理;而 @Autowire 注解相当于告诉 IoC 容器:我需要依赖这个类,你需要帮我注入进来。

3、BeanDefinition

理解了 bean,BeanDefinition 就好理解了。BeanDefinition 是 bean 的定义,用来存储 bean 的所有属性方法定义。

4、BeanFactory 和 ApplicationContext

BeanFactory:基础类型 IoC 容器,提供完整的 IoC 服务支持。

ApplicationContext:BeanFactory 的子接口,在 BeanFactory 的基础上构建,是相对比较高级的 IoC 容器实现。包含 BeanFactory 的所有功能,还提供了其他高级的特性,比如:事件发布、国际化信息支持、统一资源加载策略等。正常情况下,我们都是使用的 ApplicationContext。

以电话来举例:

我们家里使用的 “座机” 就类似于 BeanFactory,可以进行电话通讯,满足了最基本的需求。

而现在非常普及的智能手机,iPhone、小米等,就类似于 ApplicationContext,除了能进行电话通讯,还有其他很多功能:拍照、地图导航、听歌等。

5、FactoryBean

一般情况下,我们将 bean 的创建和管理都交给 Spring IoC 容器,Spring 会利用 bean 的 class 属性指定的类来实例化 bean。

但是如果我们想自己实现 bean 的创建操作,可以实现吗?答案是可以的,FactoryBean 就可以实现这个需求。

FactoryBean 是一种特殊的 bean,它是个工厂 bean,可以自己创建 bean 实例,如果一个类实现了 FactoryBean 接口,则该类可以自己定义创建实例对象的方法,只需要实现它的 getObject() 方法即可。

FactoryBean 可能对于普通开发来说基本用不到也没去注意过,但是它其实应用的非常广,特别是在中间件中,如果你看过一些中间件的源码,一定会看到 FactoryBean 的身影。

4.IOC实现

4.1添加spring相关依赖

<!--spring相关-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-expression</artifactId>
  <version>5.2.9.RELEASE</version>
</dependency>
<!--日志相关-->
<dependency>
  <groupId>commons-logging</groupId>
  <artifactId>commons-logging</artifactId>
  <version>1.1.1</version>
</dependency>
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>

4.2核心配置文件

  • 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">
    <!--
        这就是spring的核心工厂
        如何让工厂创建一个对象呢?
            bean:   表示是一个对象/类; 相当于 new UserDaoImpl();
            id/name: 二选一,表示对象名,也是对外提供的唯一标识
            class:   表示你交给工厂的哪个类(全路径)
    -->
    <bean id="userDao" class="cn.yanqi.dao.impl.UserDaoImpl"/>
</beans>

4.3获取Bean对象

/**
 * @Auther: yanqi
 * @Desc 业务层
 */
public class UserServiceImpl implements UserService 
    //注入业务层
    // private UserDao userDao = new UserDaoImpl();
    @Override
    public void login() 
        System.out.println("业务层登录!!!");
        //现在要通过spring工厂来获取bean对象,如何获取呢?
        //1、找到bean对象所在的applicationContext.xml配置文件
        //ClassPathXmlApplicationContext 会默认加载resources下的applicationContext.xml
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2、找到工厂中bean的唯一标识
        //方式一
        UserDao userDao1 = (UserDao) applicationContext.getBean("userDao");
        //方式二
        UserDao userDao2 = applicationContext.getBean("userDao", UserDao.class);

        //方式三 通过找到接口类实现对象的创建,省去了bean的id或name --了解
        UserDao userDao3 = applicationContext.getBean(UserDao.class);
        UserDao userDao4 = applicationContext.getBean(UserDaoImpl.class);
        //调用dao层方法
        userDao3.login();
    

三.DI依赖注入

DI  Dependency Injection 依赖注入,在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件
简单的说,可以将一个bean对象动态的注入到另外一个bean中

5.1配置文件

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">  
    <!--创建dao对象-->
    <bean id="userDao" class="cn.yanqi.dao.impl.UserDaoImpl"/>    
    <!--创建service对象-->
    <bean id="userService" class="cn.yanqi.service.impl.UserServiceImpl">
        <!--
            在service层注入dao对象
            property:  属性注入对象
            name:      找到service层中提供的setXX方法,把set去掉,并把首字母小写
            ref:       你要注入的哪bean对象,bean的id/name
        -->
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>

5.2属性对象注入

  • service层
/**
 * @Auther: yanqi
 * @Desc 业务层
 */
public class UserServiceImpl implements UserService 
    //属性注入
    private UserDao userDao;
    public void setUserDao(UserDao userDao) 
        this.userDao = userDao;
    
    @Override
    public void login() 
        System.out.println("业务层 登录!!!");
        //调用dao层方法
        userDao.login();
    

5.3测试

/**
 * @Auther: yanqi
 * @Desc 测试类
 */
public class UserServiceTest 
    @Test
    public void login() 
        // UserService userService = new UserServiceImpl();
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取bean对象
        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.login();
    

6.Spring核心接口

BeanFactory

这是IOC容器的顶级接口 它定义了IOC的最基础的功能, 但是其功能比较简单,一般面向Spring自身使用

在第一次使用到某个Bean时(调用getBean()),才对该Bean进行加载实例化[用的时候再创建] --> 【懒汉设计】

ApplicationContext

这是在BeanFactory基础上衍生出的接口,它扩展了BeanFactory的功能,一般面向程序员使用

在容器启动时,一次性创建并加载了所有的Bean [初始化的时候全创建好] --> 【饿汉设计】

上面两种方式创建的对象都是单例, 只是创建对象的时机不同


public class UserServiceTest 
    @Test
    public void login() 
        // UserService userService = new UserServiceImpl();
        // ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

   //BeanFactory是bean工厂的顶级接口,了解即可
    BeanFactory beanFactory = new XmlBeanFactory(newClassPathResource("applicationContext.xml"));

    //获取bean对象
    UserService userService = beanFactory.getBean("userService", UserService.class);
    userService.login();
    

四.基于XML配置方式

实例化Bean的四种方式

第一种 无参数构造器 (最常用*)

public class Bean1 

    <!--第一种: 无参构造-->
    <bean id="bean1" class="cn.yanqi.bean.Bean1"/>
    @Test
    public void login() 
        //获取配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取bean对象
        Bean1 bean1 = applicationContext.getBean("bean1", Bean1.class);
        System.out.println(bean1);
    

第二种 静态方式

public class Product 
    private Integer id;
    private String name;

public class StaticFactory 
    static Product getInstance()
        return new Product();
    

      <!--相当于这里创建一bean2Test对象,直接调用了initBean2静态方法-->
    <bean id="staticFactory" class="com.yh.pojo.StaticFactory" factory-method="getInstance"/>

    @Test
    public void login() 
        //获取配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取bean对象
        Bean2 bean2 = applicationContext.getBean("bean2", Bean2.class);
        System.out.println(bean2);
    

第三种 普通方法

public class Product 
    private Integer id;
    private String name;

public class ProFactory 
    public Product getProduct()
        return new Product();
    

    <!--第三种: 普通方法-->
    <bean id="proFactory" class="com.yh.pojo.ProFactory"/>
    <bean id="product" factory-method="getProduct" factory-bean="proFactory"/>
    @Test
    public void login() 
        //获取配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Product product = (Product) ac.getBean("product");
        System.out.println(product);
    

第四种 FactoryBean方式-了解

public class Bean4 

/**
 * @Desc  实现FactoryBean接口
 */
public class Bean4Test implements FactoryBean<Bean4>     
    //返回bean对象即可
    @Override
    public Bean4 getObject() throws Exception 
        return new Bean4();
    

    @Override
    public Class<?> getObjectType() 
        return null;
    

    <!--第四种: FactoryBean方式-->
    <bean id="bean4" class="cn.yanqi.bean.Bean4Test"/>
    @Test
    public void login() 
        //获取配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取bean对象
        Bean4 bean4 = applicationContext.getBean("bean4", Bean4.class);
        System.out.println(bean4);
    

五.Bean对象配置

相关属性

以上是关于JAVAEE框架整合技术之Spring01-IOC教程的主要内容,如果未能解决你的问题,请参考以下文章

JAVAEE框架整合技术之Spring02-AOP面向切面编程技术

JAVAEE框架整合技术之Spring02-AOP面向切面编程技术

JAVAEE框架整合技术之spring03-SpringJdbcTemplate模板技术和事务处理

JavaEE开发之Spring框架整合1

JavaEE开发之Spring框架整合2(完结撒花)

JAVAEE框架技术之14SSM综合案例

(c)2006-2024 SYSTEM All Rights Reserved IT常识

属性名描述
id在ioc容器的唯一标识
class创建对象实例的全限定名
scope声明此对象的作用范围
singleton:单例对象(默认)
prototype:多例对象
init-method在对象创建时,执行此方法
destroy-method在对象销毁时,执行此方法