spring框架 订阅
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言,绝大部分Java应用都可以从Spring中受益。◆目的:解决企业应用开发的复杂性◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能◆范围:任何Java应用Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。 展开全文
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言,绝大部分Java应用都可以从Spring中受益。◆目的:解决企业应用开发的复杂性◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能◆范围:任何Java应用Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。
信息
目    的
解决企业应用开发的复杂性
使    用
JavaBean
范    围
任何Java应用
外文名
Spring Framework
中文名
Spring框架
创建原因
软件开发的复杂性
功    能
使用基本的JavaBean代替EJB
spring框架起源
要谈Spring的历史,就要先谈J2EE。J2EE应用程序的广泛实现是在1999年和2000年开始的,它的出现带来了诸如事务管理之类的核心中间层概念的标准化,但是在实践中并没有获得绝对的成功,因为开发效率,开发难度和实际的性能都令人失望。曾经使用过EJB开发JAVA EE应用的人,一定知道,在EJB开始的学习和应用非常的艰苦,很多东西都不能一下子就很容易的理解。EJB要严格地实现各种不同类型的接口,类似的或者重复的代码大量存在。而配置也是复杂和单调,同样使用JNDI进行对象查找的代码也是单调而枯燥。虽然有一些开发工作随着xdoclet的出现,而有所缓解,但是学习EJB的高昂代价,和极低的开发效率,极高的资源消耗,都造成了EJB的使用困难。而Spring出现的初衷就是为了解决类似的这些问题。Spring的一个最大的目的就是使JAVA EE开发更加容易。同时,Spring之所以与Struts、Hibernate等单层框架不同,是因为Spring致力于提供一个以统一的、高效的方式构造整个应用,并且可以将单层框架以最佳的组合揉和在一起建立一个连贯的体系。可以说Spring是一个提供了更完善开发环境的一个框架,可以为POJO(Plain Ordinary Java Object)对象提供企业级的服务。Spring的形成,最初来自Rod Jahnson所著的一本很有影响力的书籍《Expert One-on-One J2EE Design and Development》,就是在这本书中第一次出现了Spring的一些核心思想,该书出版于2002年。另外一本书《Expert One-on-One J2EE Development without EJB》,更进一步阐述了在不使用EJB开发JAVA EE企业级应用的一些设计思想和具体的做法。有时间了可以详细的研读一下。Spring的初衷:1、JAVA EE开发应该更加简单。2、使用接口而不是使用类,是更好的编程习惯。Spring将使用接口的复杂度几乎降低到了零。3、为JavaBean提供了一个更好的应用配置框架。4、更多地强调面向对象的设计,而不是现行的技术如JAVA EE。5、尽量减少不必要的异常捕捉。6、使应用程序更加容易测试。Spring的目标:1、可以令人方便愉快的使用Spring。2、应用程序代码并不依赖于Spring APIs。3、Spring不和现有的解决方案竞争,而是致力于将它们融合在一起。Spring的基本组成:1、最完善的轻量级核心框架。2、通用的事务管理抽象层。3、JDBC抽象层。4、集成了Toplink, Hibernate, JDO, and iBATIS SQL Maps。5、AOP功能。6、灵活的MVC Web应用框架。
收起全文
精华内容
下载资源
问答
  • 帮助广大学员手把手教学,本课程从无到有,循序渐进的手写mvc框架,由于官方的框架比较复杂,为了让同学们能够学懂,先从简单地IOC框架入手,然后不断地升级和迭代,逐渐成为官方比较接近的Spring框架。希望同学们...
  • Spring框架的简单实现

    2015-03-09 08:15:09
    我们从一个简单的容器开始,一步步的重构,最后实现一个基本的Spring框架的雏形,为了帮助我们更加深入的理解Spring的IoC的原理和源码。 详细内容见博文: 【SSH进阶之路】一步步重构容器实现Spring框架——从一个...
  • Spring入门第一讲——Spring框架的快速入门

    万次阅读 多人点赞 2017-04-08 00:27:34
    Spring是一个开源框架Spring是于2003年兴起的一个轻量级的Java开发框架,由Rod Johnson创建。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架Spring是一个开源框架Spring是于2003年...

    Spring的概述

    什么是Spring?

    我们可以从度娘上看到这样有关Spring的介绍:
    在这里插入图片描述
    说得更加详细一点,Spring是一个开源框架,Spring是于2003年兴起的一个轻量级的Java开发框架,由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。
    为什么说Spring是一个一站式的轻量级开源框架呢?EE开发可分成三层架构,针对JavaEE的三层结构,每一层Spring都提供了不同的解决技术。
    在这里插入图片描述
    从对Spring的简要介绍中,我们知道了Spring的核心有两部分:

    • IoC:即控制反转。举例来说,在之前的操作中,比方说有一个类,我们想要调用类里面的方法(不是静态方法),就要创建该类的对象,使用对象调用方法来实现。但对于Spring来说,Spring创建对象的过程,不是在代码里面实现的,而是交给Spring来进行配置实现的;
    • AOP:即面向切面编程。之前,讲Struts2框架的拦截器时,我们就已稍微讲了一下,在Spring后续的学习过程中,我们会着重来讲它,但是本文并不会过多阐述它。

    为什么学习Spring?

    在度娘上查看有关Spring的介绍时,我们可以找到如下一系列Spring的优点,这就是我们要学习Spring框架的原因。
    在这里插入图片描述

    Spring的快速入门

    Spring的版本

    需要说明的是,本系列入门Spring的教程使用的版本是spring-framework-4.2.4.RELEASE。

    IoC概述

    什么是IoC?

    IoC即Inversion of Control,反应过来就是控制反转。啥是控制反转啊?控制反转指的就是将对象的创建权反转给(交给)了Spring,其作用是实现了程序的解耦合。也可这样解释:获取对象的方式变了,对象创建的控制权不是"使用者",而是"框架"或者"容器"。用更通俗的话来说,IoC就是指对象的创建,并不是在代码中用new操作new出来的,而是通过Spring进行配置创建的。

    Spring的IoC的底层实现原理

    这里先给出结论:Spring的IoC的底层实现原理是工厂设计模式+反射+XML配置文件。 就拿持久层(也即dao层,data access object,数据访问对象)的开发来说,官方推荐做法是先创建一个接口,然后再创建接口对应的实现类。所以,这里,我会以dao层的开发为例来证明Spring的IoC的底层实现原理就是工厂设计模式+反射+XML配置文件。
    首先,创建一个Userdao接口。

    public interface UserDao {
    	public void add();
    }
    

    然后,再创建Userdao接口的一个实现类(UserDaoImpl.java)。

    public class UserDaoImpl implements UserDao {
        public void add() {
    	    balabala......
        }
    }
    

    接着,我们在service层中调用dao层,核心代码如下:

    // 接口 实例变量 = new 实现类
    UserDao dao = new UserDaoImpl();
    dao.add();
    

    这时我们便可发现一个缺点:service层和dao层耦合度太高了,即接口和实现类有耦合(它俩之间的联系过于紧密),一旦切换底层实现类,那么就需要修改源代码,这真的不是一个好的程序设计,好的程序设计应当满足OCP原则(也即开闭原则),即在尽量不修改程序源代码的基础上对程序进行扩展。说到这里,我就不得不稍微讲一下面向对象设计的七大原则了,它不必强记,重在理解。
    在这里插入图片描述
    出现的这个问题该如何解决呢?解决方法是使用工厂设计模式进行解耦合操作。所以,我们需要创建一个工厂类,在工厂类中提供一个方法,返回实现类的对象。

    public class BeanFactory {
        // 提供返回实现类对象的方法
        public static UserDao getUserDao() {
            return new UserDaoImpl();
        }
    }
    

    这样,在service层中调用dao层的核心代码就变为了下面的样子。

    UserDao dao = BeanFactory.getUserDao();
    dao.add();
    

    如若这样做,会发现又产生了一个缺点:现在接口和实现类之间是没有耦合了,但是service层和工厂类耦合了。如果真正想实现程序之间的解耦合,那么就需要使用到工厂设计模式+反射+XML配置文件了。所以,我们这里提供一个XML配置文件,并且该配置文件中有如下配置信息。

    <bean id="userDao" class="com.meimeixia.dao.impl.UserDaoImpl" />
    

    然后再来创建一个工厂类,在工厂类中提供一个返回实现类对象的方法,但并不是直接new实现类,而是使用SAX解析配置文件,根据标签bean中的id属性值得到对应的class属性值,使用反射创建实现类对象。

    public class BeanFactory {
        public static Object getBean(String id) {
            // 1.使用SAX解析得到配置文件内容
            // 直接根据id值userDao得到class属性值
            String classvalue = "class属性值";
            // 2.使用反射得到对象
            Class clazz = Class.forName(classvalue);
            UserDaoImpl userDaoImpl = (UserDaoImpl)lazz.newInstance();
            return userDaoImpl;
        }
    }
    

    以上就是Spring的IoC的底层实现原理。

    Spring的IoC入门

    下载Spring的开发包

    Spring的官网是https://spring.io/,Spring的开发包的下载地址是https://repo.spring.io/libs-release-local/org/springframework/spring/,上面说过,我下载的是spring-framework-4.2.4.RELEASE这个版本的Spring。解压缩之后,可发现Spring开发包的目录结构如下。
    在这里插入图片描述

    创建web项目,引入Spring的开发包

    首先创建一个动态web项目,例如spring_demo01,然后导入Spring框架相关依赖jar包,要导入哪些jar包呢?这是一个问题。
    在这里插入图片描述
    由于我们只是初次入门Spring,所以也只是使用到了Spring的基本功能,从上图红框框中的部分可知,我们需要使用到下面的这4个jar包。
    在这里插入图片描述
    除此之外,还要导入Spring支持的日志jar包,也就是下面两个jar包。
    在这里插入图片描述
    关于以上两个jar包,我稍微做一下解释,com.springsource.org.apache.commons.logging-1.1.1.jar它里面都是一些接口,有接口,那当然要有实现类了,恰好,com.springsource.org.apache.log4j-1.2.15.jar里面就是那些接口的实现类。使用Log4j,我们可以查看到当前运行程序中对象创建的过程,也可以看到更详细的信息,Log4j适合使用在程序调试中。
    导入完日志相关的jar包之后,我们还要导入日志记录文件,即在src目录下引入Log4j的配置文件(log4j.properties),该文件内容如下:

    ### direct log messages to stdout ###
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target=System.err
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    
    ### direct messages to file mylog.log ###
    log4j.appender.file=org.apache.log4j.FileAppender
    log4j.appender.file.File=c\:mylog.log
    log4j.appender.file.layout=org.apache.log4j.PatternLayout
    log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    
    ### set log levels - for more verbose logging change 'info' to 'debug' ###
    # error warn info debug trace
    log4j.rootLogger= info, stdout
    

    对以上日志记录文件,我会粗略讲解一下。
    在这里插入图片描述
    从上图可知,log4j.rootLogger就是用于设置日志的输出级别,那么日志的输出级别有几种呢?有如下5种。
    在这里插入图片描述

    创建接口和实现类

    首先,在src目录下创建一个com.meimeixia.spring.demo01包,并在该包下创建一个名为UserDao的接口。

    package com.meimeixia.spring.demo01;
    
    /**
     * 用户管理的dao层的接口
     * @author liayun
     *
     */
    public interface UserDao {
    
    	public void save();
    	
    }
    

    然后,在com.meimeixia.spring.demo01包下创建UserDao接口的一个实现类——UserDaoImpl.java。

    package com.meimeixia.spring.demo01;
    
    /**
     * 用户管理的dao层接口的实现类
     * @author liayun
     *
     */
    public class UserDaoImpl implements UserDao {
    
    	@Override
    	public void save() {
    		System.out.println("UserDaoImpl中的save方法执行了......");
    	}
    	
    }
    

    将实现类交给Spring管理

    首先,我们需要创建Spring的配置文件,Spring配置文件的名称和位置没有固定要求,一般建议把该文件放到src目录下面,名称可随便写,官方建议写成applicationContext.xml。然后我们还需要在配置文件中引入约束,Spring学习阶段的约束是schema约束。那么问题来了,这个约束又该怎么写呢?可参考docs\spring-framework-reference\html目录下的xsd-configuration.html文件,在其内容最后面找到如下内容。
    在这里插入图片描述
    将其复制黏贴到配置文件applicationContext.xml中,这样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">
            
    </beans>
    

    最后,咱还要将实现类交给Spring来管理,即在配置文件中配置对象的创建。

    <?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="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl"></bean>
    	
    </beans>
    

    编写测试类

    我们要在Spring中写代码来实现获取applicationContext.xml文件中配置的对象,这段代码不要求大家重点掌握,只是用在测试中而已。这段代码主要用来解析Spring配置文件得到对象,但这个过程不需要我们写代码来实现了,Spring已经封装了一个对象来帮我们进行了这些操作,这个对象叫ApplicationContext,它就能实现这个功能。于是,我们需要在com.meimeixia.spring.demo01包下创建一个SpringDemo01的单元测试类。

    package com.meimeixia.spring.demo01;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    /**
     * Spring的入门
     * @author liayun
     *
     */
    public class SpringDemo01 {
    	
    	/*
    	 * 传统方式的调用
    	 */
    	@Test
    	public void demo01() {
    		UserDao userDao = new UserDaoImpl();
    		userDao.save();
    	}
    	
    	/*
    	 * Spring的方式的调用
    	 */
    	@Test
    	public void demo02() {
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");// classpath就是类路径,src目录下的文件最终要编译到类路径下
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    
    }
    

    然后,运行以上demo02单元测试方法,Eclipse控制台就会打印如下内容。
    在这里插入图片描述

    Spring IoC和DI的区别

    IoC上面我已经讲过了,它指的就是将对象的创建权反转给(交给)了Spring。那DI又是什么鬼呢?DI,即Dependency Injection,翻译过来就是依赖注入,它指的就是Spring在管理某个类的时候会将该类依赖的属性注入(设置)进来,也就是说在创建对象的过程中,向类里面的属性中设置值。注意:依赖注入不能单独存在,须在控制反转基础之上完成,用更通俗点的话来说,就是注入类里面的属性值,不能直接注入,须创建类的对象再完成注入。
    你还记得在面向对象设计的时候,类和类之间有几种关系吗?有3种,它们分别是:

    • 依赖,由于下图中B类的方法用到了A类,所以此时就可以说B类依赖于A类;
      在这里插入图片描述
    • 继承(is a),这种关系我们应该是见的要吐了;
      在这里插入图片描述
    • 聚合(has a),它有松散和紧密之分。例如,球队得有一个守门员,即使这个球队没有了这个守门员,它也还是一个球队,所以它是松散的;人得有一个脑袋,此时它就是紧密的。

    说了这么多,咱就通过一个案例来看看DI在程序的体现。现在,我们想要给UserDaoImpl这个实现类里面的某一个属性(例如String类型的name)设置值,该咋怎呢?首先,将UserDaoImpl这个实现类修改成下面这个样子。

    package com.meimeixia.spring.demo01;
    
    /**
     * 用户管理的dao层接口的实现类
     * @author liayun
     *
     */
    public class UserDaoImpl implements UserDao {
    	
    	private String name;
    	
    	//提供set方法
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void save() {
    		System.out.println("UserDaoImpl中的save方法执行了......" + name);
    	}
    	
    }
    

    如果使用传统的方式来为UserDaoImpl实现类的name属性设置值,那么SpringDemo01单元测试类中的demo01方法就应该写成下面这个样子。

    package com.meimeixia.spring.demo01;
    
    import org.junit.Test;
    
    /**
     * Spring的入门
     * @author liayun
     *
     */
    public class SpringDemo01 {
    	
    	/*
    	 * 传统方式的调用
    	 */
    	@Test
    	public void demo01() {
    		/*
    		 * 我想给这个类里面的某一个属性设置值,挺麻烦的!
    		 * 
    		 * 1. 不能面向接口编程了
    		 * 2. 你还得手动调用set方法,也得去改变程序的源代码
    		 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    
    }
    

    这样写,就有两个缺点,一是不能面向接口编程了,二是咱还得手动调用对象的set方法,这必然就涉及到要改变程序的源代码了,这是我们不能接受的!
    如果使用了依赖注入,即在applicationContext.xml文件中为配置好的UserDaoImpl实现类的name属性注入一个值,那么情况就完全不同了,以上两个缺点也就不复存在了。

    <?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="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl">
    		<!-- DI:依赖注入 -->
    		<property name="name" value="李二" />
    	</bean>
    	
    </beans>
    

    此时,SpringDemo01单元测试类中的demo02方法依然不变,如下。

    package com.meimeixia.spring.demo01;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    /**
     * Spring的入门
     * @author liayun
     *
     */
    public class SpringDemo01 {
    	
    	/*
    	 * 传统方式的调用
    	 */
    	@Test
    	public void demo01() {		
    		/*
    		 * 我想给这个类里面的某一个属性设置值,挺麻烦的!
    		 * 
    		 * 1. 不能面向接口编程了
    		 * 2. 你还得手动调用set方法,也得去改变程序的源代码
    		 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    	
    	/*
    	 * Spring的方式的调用
    	 */
    	@Test
    	public void demo02() {
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    
    }
    

    运行以上demo02单元测试方法,Eclipse控制台就会打印出如下内容。
    在这里插入图片描述

    Spring的工厂类

    Spring工厂类的结构图

    在这里插入图片描述
    从上图可以看出ApplicationContext(接口)继承自BeanFactory(接口)。

    BeanFactory:老版本的工厂类

    BeanFactory是老版本的工厂类,稍微了解一下就好,这个类在实际开发中我们并不需要用到。需要说明的一点是,它只有在调用getBean方法的时候,才会生成Spring所管理的类的实例。

    ApplicationContext:新版本的工厂类

    ApplicationContext是新版本的工厂类,它在加载配置文件的时候,就会将Spring所管理的类都实例化。ApplicationContext这个接口有两个实现类,如下图所示。
    在这里插入图片描述
    ClassPathXmlApplicationContext这个实现类前面用过了,下面咱就来用一下FileSystemXmlApplicationContext这个实现类。首先,拷贝一份applicationContext.xml文件到C盘下,其内容做一点点修改。
    在这里插入图片描述
    然后,在SpringDemo01单元测试类中编写如下一个demo03方法。

    package com.meimeixia.spring.demo01;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    /**
     * Spring的入门
     * @author liayun
     *
     */
    public class SpringDemo01 {
    	
    	/*
    	 * 传统方式的调用
    	 */
    	@Test
    	public void demo01() {	
    		/*
    		 * 我想给这个类里面的某一个属性设置值,挺麻烦的!
    		 * 
    		 * 1. 不能面向接口编程了
    		 * 2. 你还得手动调用set方法,也得去改变程序的源代码
    		 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    	
    	/*
    	 * Spring的方式的调用
    	 */
    	@Test
    	public void demo02() {
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    	
    	/*
    	 * 加载磁盘上的配置文件
    	 */
    	@Test
    	public void demo03() {
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new FileSystemXmlApplicationContext("C:\\applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    
    }
    

    最后,运行以上demo03单元测试方法,Eclipse控制台就会打印出如下内容。
    在这里插入图片描述

    展开全文
  • Spring框架参考文档(中文版PDF)Spring框架参考文档(中文版PDF)
  • 什么是spring框架spring框架究竟有什么用呢?我们可以用spring框架来做些什么呢?让我们来具体了解一下,以及经常所说的IOC和AOP是一种怎样的思想,到底是怎么实现这些思想的!

    什么是spring框架,spring框架究竟有什么用呢?我们可以用spring框架来做些什么呢?这是我今天要说的内容。

    当然,百度spring框架会出现一大堆spring框架的介绍,以及IOC和AOP。但是这些官方的语言,看书都有解释,关键是我不知道为什么要用spring,spring框架和不用框架到底区别在哪,还有它到底是通过什么来表明我用的框架就是spring框架的?

    spring很抽象,spring是框架,框架的主要目的是什么呢?大概所有框架的目的都一样吧,那就是简化开发。而它存在的目的也是为了简化java开发。

    它是怎样来简化开发的呢?让我们看看spring采取的关键策略。

    • 基于POJO的轻量级和最小侵入性编程;
    • 通过依赖注入和面向接口实现松耦合;
    • 基于切面和惯例进行声明式编程;
    • 通过切面和模板减少样板式代码。

    这就是spring框架的四种关键策略。我们下面详细谈谈。

    spring框架的最小侵入性

    Spring竭力避免因自身的API而弄乱你的应用代码。 Spring不会强迫你实现Spring规范的接口或继承Spring规范的类, 相反, 在基于Spring构建的应用中, 它的类通常没有任何痕迹表明你使用了Spring。只能通过xml配置文件来看出spring的思想。

    最坏的场景是, 一个类或许会使用Spring注解, 但它依旧是POJO。

    那可能有人要问了,不侵入如何实现spring框架强大的功能,spring框架不是很强大吗?在这里我要说明,spring框架是很强大,但它的强大在于它的理念,它的思想,而不是它实现了多强大的功能。

    当然不侵入有不侵入的解决方法,在我的理解里它的解决方法也算是spring的核心吧!那就是配置文件或者注解

    让我们来看一个javabean。它是一个普通的java类。

    public class exampleBean(){
        public String testPrint(){
            System.out.println("===test===");
        }
    }

    Spring的非入侵式就是不强制类要实现Spring的任何接口或类,没有任何地方表明它是一个Spring组件。 意味着这个类在Spring应用和非Spring应用中都可以发挥同样的作用。

    那这个类在不耦合的情况下是如何发挥作用的呢?这就要提到spring框架的DI(依赖注入)了。

    依赖注入

    任何一个有实际意义的应用都会由两个或者更多的类组成, 这些类相互之间进行协作来完成特定的业务逻辑。 按照传统的做法, 每个对象负责管理与自己相互协作的对象(即它所依赖的对象) 的引用, 这将会导致高度耦合和难以测试的代码。而spring框架利用依赖注入恰恰解决了这一难题。

    耦合具有两面性 。 一方面, 紧密耦合的代码难以测试、 难以复用、 难以理解, 并且典型地表现出“打地鼠”式的bug特性 。 另一方面, 一定程度的耦合又是必须的——完全没有耦合的代码什么也做不了。 为了完成有实际意义的功能, 不同的类必须以适当的方式进行交互。 总而言之, 耦合是必须的, 但应当被小心谨慎地管理。

    public void DealData(){
        public Data data;
        public void setData(Data data){
            this.data=data;
        }
        public void add(){
            data.add();
        }
    
    }

    如上图,DealData类和Data类耦合了。

    通过DI, 对象的依赖关系将由系统中负责协调各对象的第三方组件在创建对象的时候进行设定。 对象无需自行创建或管理它们的依赖关系。

    应用切面

    DI能够让相互协作的软件组件保持松散耦合, 而面向切面编程(aspect-oriented programming, AOP) 允许你把遍布应用各处的功能分离出来形成可重用的组件。

    面向切面编程往往被定义为促使软件系统实现关注点的分离一项技术。 系统由许多不同的组件组成, 每一个组件各负责一块特定功能。 除了实现自身核心的功能之外, 这些组件还经常承担着额外的职责。 诸如日志、 事务管理和安全这样的系统服务经常融入到自身具有核心业务逻辑的组件中去, 这些系统服务通常被称为横切关注点, 因为它们会跨越系统的多个组件。

    如果将这些关注点分散到多个组件中去, 你的代码将会带来双重的复杂性。

    • 实现系统关注点功能的代码将会重复出现在多个组件中。 这意味着如果你要改变这些关注点的逻辑, 必须修改各个模块中的相关实现。
    • 即使你把这些关注点抽象为一个独立的模块, 其他模块只是调用它的方法, 但方法的调用还是会重复出现在各个模块中。
    • 组件会因为那些与自身核心业务无关的代码而变得混乱。 一个向地址簿增加地址条目的方法应该只关注如何添加地址, 而不应该关注它是不是安全的或者是否需要支持事务

    图1.2展示了这种复杂性。 左边的业务对象与系统级服务结合得过于紧密。 每个对象不但要知道它需要记日志、 进行安全控制和参与事务, 还要亲自执行这些服务。

    image.png

    在整个系统内, 关注点(例如日志和安全)的调用经常散布到各个模块中, 而这些关注点并不是模块的核心业务

    AOP能够使这些服务模块化, 并以声明的方式将它们应用到它们需要影响的组件中去。 所造成的结果就是这些组件会具有更高的内聚性并且会更加关注自身的业务, 完全不需要了解涉及系统服务所带来复杂性。 总之, AOP能够确保POJO的简单性。

    如图1.3所示, 我们可以把切面想象为覆盖在很多组件之上的一个外壳。 应用是由那些实现各自业务功能的模块组成的。 借助AOP, 可以使用各种功能层去包裹核心业务层。 这些层以声明的方式灵活地应用到系统中, 你的核心应用甚至根本不知道它们的存在。 这是一个非常强大的理念, 可以将安全、 事务和日志关注点与核心业务逻辑相分离。

    image.png

    利用AOP, 系统范围内的关注点覆盖在它们所影响组件之上

    为了示范在Spring中如何应用切面, 让我们重新回到骑士的例子, 并为它添加一个切面。

    每一个人都熟知骑士所做的任何事情, 这是因为吟游诗人用诗歌记载了骑士的事迹并将其进行传唱。 假设我们需要使用吟游诗人这个服务类来记载骑士的所有事迹。 程序清单1.9展示了我们会使用的Minstrel类。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    
    package sia.knights;
    
    import java.io.PrintStream;
    
    public class Minstrel {
    
      private PrintStream stream;
      
      public Minstrel(PrintStream stream) {
        this.stream = stream;
      }
    
      public void singBeforeQuest() {
        stream.println("Fa la la, the knight is so brave!");
      }
    
      public void singAfterQuest() {
        stream.println("Tee hee hee, the brave knight " +
        		"did embark on a quest!");
      }
    
    }
    

    正如你所看到的那样, Minstrel是只有两个方法的简单类。 在骑士执行每一个探险任务之前, singBeforeQuest()方法会被调用; 在骑士完成探险任务之后, singAfterQuest()方法会被调用。 在这两种情况下, Minstrel都会通过一个PrintStream类来歌颂骑士的事迹, 这个类是通过构造器注入进来的。

    把Minstrel加入你的代码中并使其运行起来, 这对你来说是小事一桩。 我们适当做一下调整从而让BraveKnight可以使用Minstrel。 程序清单1.10展示了将BraveKnight和Minstrel组合起来的第一次尝试。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    
    package sia.knights;
      
    public class BraveKnight implements Knight {
    
      private Quest quest;
      private Minstrel minstrel;
    
      public BraveKnight(Quest quest, Minstrel minstrel) {
        this.quest = quest;
    	this.minstrel = minstrel;
      }
    
      public void embarkOnQuest() {
    	minstrel.singBeforeQuest();
        quest.embark();
    	minstrel.singAfterQuest();
      }
    
    }
    

    这应该可以达到预期效果。 现在, 你所需要做的就是回到Spring配置中, 声明Minstrel bean并将其注入到BraveKnight的构造器之中。

    但是, 请稍等……

    我们似乎感觉有些东西不太对。 管理他的吟游诗人真的是骑士职责范围内的工作吗? 在我看来, 吟游诗人应该做他份内的事, 根本不需要骑士命令他这么做。 毕竟, 用诗歌记载骑士的探险事迹, 这是吟游诗人的职责。 为什么骑士还需要提醒吟游诗人去做他份内的事情呢?此外, 因为骑士需要知道吟游诗人, 所以就必须把吟游诗人注入到BarveKnight类中。 这不仅使BraveKnight的代码复杂化了, 而且还让
    我疑惑是否还需要一个不需要吟游诗人的骑士呢? 如果Minstrel为null会发生什么呢? 我是否应该引入一个空值校验逻辑来覆盖该场景?

    简单的BraveKnight类开始变得复杂, 如果你还需要应对没有吟游诗人时的场景, 那代码会变得更复杂。 但利用AOP, 你可以声明吟游诗人必须歌颂骑士的探险事迹, 而骑士本身并不用直接访问Minstrel的方法。

    要将Minstrel抽象为一个切面, 你所需要做的事情就是在一个Spring配置文件中声明它。 程序清单1.11是更新后的knights.xml文件, Minstrel被声明为一个切面。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:aop="http://www.springframework.org/schema/aop"
      xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
    		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
      <bean id="knight" class="sia.knights.BraveKnight">
        <constructor-arg ref="quest" />
      </bean>
    
      <bean id="quest" class="sia.knights.SlayDragonQuest">
        <constructor-arg ref="fakePrintStream" />
      </bean>
    
      <bean id="minstrel" class="sia.knights.Minstrel">
        <constructor-arg ref="fakePrintStream" />
      </bean>
    
      <bean id="fakePrintStream" class="sia.knights.FakePrintStream" />
    
      <aop:config>
        <aop:aspect ref="minstrel">
          <aop:pointcut id="embark"
              expression="execution(* *.embarkOnQuest(..))"/>
            
          <aop:before pointcut-ref="embark" 
              method="singBeforeQuest"/>
    
          <aop:after pointcut-ref="embark" 
              method="singAfterQuest"/>
        </aop:aspect>
      </aop:config>
    
    </beans>
    

    这里使用了Spring的aop配置命名空间把Minstrel bean声明为一个切面。 首先, 需要把Minstrel声明为一个bean, 然后在元素中引用该bean。 为了进一步定义切面, 声明(使用) 在embarkOnQuest()方法执行前调用Minstrel的singBeforeQuest()方法。 这种方式被称为前置通知(before advice) 。 同时声明(使用)在embarkOnQuest()方法执行后调用singAfter Quest()方法。 这种方式被称为后置通知(after advice) 。

    首先, Minstrel仍然是一个POJO, 没有任何代码表明它要被作为一个切面使用。 当我们按照上面那样进行配置后, 在Spring的上下文中, Minstrel实际上已经变成一个切面了。

    其次, 也是最重要的, Minstrel可以被应用到BraveKnight中, 而BraveKnight不需要显式地调用它。 实际上, BraveKnight完全不知道Minstrel的存在。

    必须还要指出的是, 尽管我们使用Spring魔法把Minstrel转变为一个切面, 但首先要把它声明为一个Spring bean。 能够为其他Spring bean做到的事情都可以同样应用到Spring切面中, 例如为它们注入依赖。

    使用模板消除样板式代码

    你是否写过这样的代码, 当编写的时候总会感觉以前曾经这么写过? 我的朋友, 这不是似曾相识。 这是样板式的代码(boilerplate code) 。 通常为了实现通用的和简单的任务, 你不得不一遍遍地重复编写这样的代码。

    遗憾的是, 它们中的很多是因为使用Java API而导致的样板式代码。 样板式代码的一个常见范例是使用JDBC访问数据库查询数据。 举个例子, 如果你曾经用过JDBC, 那么你或许会写出类似下面的代码。

    image.png

    正如你所看到的, 这段JDBC代码查询数据库获得员工姓名和薪水。 我打赌你很难把上面的代码逐行看完, 这是因为少量查询员工的代码淹没在一堆JDBC的样板式代码中。 首先你需要创建一个数据库连接, 然后再创建一个语句对象, 最后你才能进行查询。

    为了平息JDBC可能会出现的怒火, 你必须捕捉SQLException, 这是一个检查型异常, 即使它抛出后你也做不了太多事情。

    最后, 毕竟该说的也说了, 该做的也做了, 你不得不清理战场, 关闭数据库连接、 语句和结果集。 同样为了平息JDBC可能会出现的怒火, 你依然要捕SQLException。

    程序清单1.12中的代码和你实现其他JDBC操作时所写的代码几乎是相同的。 只有少量的代码与查询员工逻辑有关系, 其他的代码都是JDBC的样板代码。

    JDBC不是产生样板式代码的唯一场景。 在许多编程场景中往往都会导致类似的样板式代码, JMS、 JNDI和使用REST服务通常也涉及大量的重复代码。

    Spring旨在通过模板封装来消除样板式代码。 Spring的JdbcTemplate使得执行数据库操作时, 避免传统的JDBC样板代码成为了可能

    举个例子, 使用Spring的JdbcTemplate(利用了 Java 5特性的JdbcTemplate实现) 重写的getEmployeeById()方法仅仅关注于获取员工数据的核心逻辑, 而不需要迎合JDBC API的需求。 程序清单1.13展示了修订后的getEmployeeById()方法。

    image.png

    正如你所看到的, 新版本的getEmployeeById()简单多了, 而且仅仅关注于从数据库中查询员工。 模板的queryForObject()方法需要一个SQL查询语句, 一个RowMapper对象(把数据映射为一个域对象) , 零个或多个查询参数。 GetEmp loyeeById()方法再也看不到以前的JDBC样板式代码了, 它们全部被封装到了模板中。

    我已经向你展示了Spring通过面向POJO编程、 DI、 切面和模板技术来简化Java开发中的复杂性。 在这个过程中, 我展示了在基于XML的配置文件中如何配置bean和切面。

    但这些文件是如何加载的呢? 它们被加载到哪里去了? 让我们再了解下Spring容器, 这是应用中的所有bean所驻留的地方。下次聊。

    参考自:https://blog.csdn.net/huanghanqian/article/details/79340762

    展开全文
  • spring框架三层架构_Spring框架架构

    千次阅读 2020-07-05 18:35:52
    spring框架三层架构 这是Spring Framework Architecture的概述。 了解Spring Framework的各个组成部分如何组织以及如何相互联系。 如果您想了解什么是Spring框架及其功能,请阅读Spring框架简介 。 总览 Spring是...

    spring框架三层架构

    这是Spring Framework Architecture的概述。 了解Spring Framework的各个组成部分如何组织以及如何相互联系。 如果您想了解什么是Spring框架及其功能,请阅读Spring框架简介

    总览

    Spring是一个模块化框架 。 它不是作为一个软件包或多个模块捆绑在一起的。 各种弹簧组件作为独立模块提供。 这使我们可以灵活地使用所需的内容,而剩下的就剩下了。 例如,如果我们要使用Spring JMS模块,则无需将Spring Web Module添加到我们的项目中。 这使我们的应用程序重量轻且集中。

    Spring框架

    Spring建筑

    让我们深入了解Spring Architecture(参考图),在本教程的后续部分中,我们将深入研究每个模块。 如图所示,Core是Spring框架的基础。 其他模块,例如Web,数据访问和其他模块集。 测试模块(也基于内核)是独立的,因为它与测试应用程序的弹簧支持组件有关。

    核心容器

    核心容器是Spring的心脏。 它包含一些基本框架类和工具。 整个Spring框架基于Core Container的顶部

    Spring框架

    核心容器模块

    小费:
    如果您是一个完整的新手。 核心容器是您首先要熟悉的东西。 如果您对此有所了解,则可以轻松选择任何Spring模块。

    弹簧芯

    核心模块包含基本的Spring Framework类,包括依赖注入(DI)和控制反转(IOC)。 Spring Core可在Spring Core Repo中获得 。 无论您要构建哪种类型的Spring应用程序,您都将始终对Spring Core具有直接或间接的依赖性。

    Spring Bean

    Spring Bean模块管理bean的生命周期。 在Spring Framework中,Bean是在Spring中注册的任何Java类,并且Spring管理这些bean类。 Spring Bean模块具有一个Bean Factory ,该工厂创建Bean实例,解析Bean与Bean的依赖关系,并根据名称或类型自动装配Bean。
    可以在Spring Beans Repo上找到Spring Bean模块。

    春天语境

    我们了解到,Spring Bean负责管理Spring Bean。 这些Spring Bean在称为Context的上下文中定义。 在Spring中,每个对象都是一个Bean,让它成为配置条目或用户定义的类(例如Employee)。 所有此类bean,它们的构造函数或工厂方法以及相关性均在Context中定义。 通过Context访问Bean。

    在大多数情况下,Spring Context是在Spring Application启动时启动的,因此称为Application Context。 链接到Spring Context Repo

    SpEL

    SpEL代表Spring Expression Language ,它是功能强大的完整表达语言。 它用于在运行时将表达式解析为值。 SpEL可以在运行时查询对象图,并且可以在基于XML或基于注释的Bean定义和Bean配置中使用。 在这里,运行时一词非常重要,因为可以根据运行时配置或其他表达式的值来评估表达式。
    可以在Spring Expression Language Repo中找到

    Spring网

    从名称本身就很明显, Spring Web组件用于构建Web应用程序。 使用Spring Web模块,我们可以构建完整的MVC应用程序,拦截器,Web服务,Portlet。

    Spring框架

    网络模块

    让我们简要看一下Web组件。

    Spring Web和Servlet

    Spring Web和Servlet提供了许多用于构建Web集成的功能。 在以上部分之一中,我们看到了什么是应用程序上下文。 Spring Web提供了类似于上下文的Web应用程序上下文。 Spring Web提供了servlet的抽象以及控制反转(IOC)。
    可以在Spring Web Repo上找到。

    Spring Web还有另外一个组件,那就是Spring MVC。 Spring MVC提供了一种用于构建基于Model View Controller的Web应用程序的机制。 Spring MVC具有“视图和操作”的概念。 视图表示用户界面或使用者,而操作是服务于Web请求的组件。
    可以在Spring Web MVC Repo中找到

    Spring Web套接字

    Spring Web Sockets支持构建Web Sockets。 Web套接字是Web应用程序中服务和使用者之间的一种隧道。 在HTTP连接中,客户端必须在服务器上轮询是否有更新。 使用Web套接字,它们之间都存在一个双向通信套接字,因此,即使服务器也可以将消息直接推送到客户端。
    可以在Spring Web Sockets Repo中找到

    Spring Web Portlet

    Spring Web Portlet支持构建Web Poerlet。 Portlet是可插拔的用户界面软件组件,可以在Web门户中进行管理和显示。 换句话说,它是一种在单个用户界面上显示多个应用程序(portlet)的用户界面的机制。 通常,这些portlet是可插拔和可安排的。
    可以在Spring Web Portlet Repo中找到

    Spring数据访问

    Spring Data Access是一组模块,用于访问各种格式的数据,包括数据库,消息传递和XML。 让我们简要介绍一下这些模块

    Spring框架

    资料存取模组

    Spring JDBC

    Spring JDBC通过Java JDBC API提供抽象。 当我们需要从数据库访问数据时,通常需要处理语句,查询,结果集,尤其是异常。 Spring JDBC抽象消除了所有这些复杂性,并提供了JdbcTemplate来轻松访问数据。 它还提供了迭代和映射结果集的方法。
    可以在Spring JDBC Repo中找到。

    SpringORM

    Spring ORM提供了与各种ORM实现集成的支持。 ORM代表对象关系映射框架,其中数据被逐字段映射到Java Object。 使用ORM框架,可以用数据填充纯Java对象,并将其传递给ORM API,以纯Java对象的形式存储和类似地检索数据。 Spring提供了对流行的ORM框架(如Hibernate,JDO和JPA)的支持。
    可以在Spring Object / Relational Mapping Repo中找到

    SpringJMS

    JMS代表Java Messaging Service,它以消息的形式定义发布者和订阅者通信的规范。 Spring JMS提供了对各种JMS实现(例如ActiveMQ和RabbitMQ)的抽象。
    可以在Spring JMS Repo中找到。

    SpringOXM

    Spring OXM提供了Java OXM实现的抽象。 Java OXM(对象XML编组)规范定义了以XML形式传输和访问数据的方式。 OXM有各种实现,例如JAXB和XStream。
    可以在Spring Object / XML Marshalling Repo上找到Cab。

    Spring交易

    Spring Transactions Management API提供了管理数据对象和数据库事务的统一方法。 Transaction API支持程序化和声明性事务管理。
    可以在Spring Transaction Repo中找到。

    杂项模块

    现在我们到达了教程的最后一部分。 在本节中,我们将学习Spring重要的独立模块,可以视为杂类。

    Spring框架

    杂项模块

    SpringAOP

    Spring AOP是面向方面编程的实现。 方面是对象需要执行的任何辅助任务。 每个对象都是Java的专门职责,除此之外,它可能还必须做一些次要的事情,例如日志记录或异常处理。 面向方面的编程提供了一种机制,可以从对象中消除此类次要责任,并将其赋予代理对象,从而使原始对象加倍。
    可以在Spring AOP Repo中找到。

    春天的方面

    我们已经了解了什么是面向方面的编程。 Spring Aspects提供了与其他面向方面的编程实现(如AspecJ)集成的统一方法。
    可以在Spring Aspects Repo中找到。

    弹簧仪表

    Spring Instrumentation模块为类检测提供支持。 该工具用于监视应用程序的性能。 它监视各种对象以诊断应用程序问题并记录它们。
    可以在Spring Instrument Repo找到。

    Spring信息

    Spring Messaging提供了与消息传递系统集成的支持。 该模块提供了与各种消息传递服务进行交互的简化且统一的方式。
    可以在Spring Messaging Repo中找到。

    摘要

    在本文中,我们研究了Spring Framework Architecture。 Spring是一个具有多个模块的巨大框架。 核心容器是Spring一切的骨干,其他所有模块都依赖于核心。 除了核心,我们还研究了Spring Web,Spring Data Access和一些其他模块。
    在接下来的部分中,我们将继续探索Spring Framework。 敬请关注!

    翻译自: https://www.javacodegeeks.com/2019/02/spring-framework-architecture.html

    spring框架三层架构

    展开全文
  • Spring框架学习总结(上)

    万次阅读 多人点赞 2019-08-08 11:51:28
    在学习SSM框架中,Spring框架我建议最好先学,平时开发接触最多的估计就是IOC容器,它可以装载bean(也就是我们java中的类,当然也包括service dao里面的),有了这个机制,我们就不用在每次使用这个类的时候为它...

    1、Spring的概述

    在学习SSM框架中,我建议初学者最好先学Spring框架,其次mybatis接着springMVC,先学mybatis当然也是可以的,今天我们就以绝对优雅的姿态闯进Spring世界,系好安全带,准备好了吗,出发了哦!!!咳咳…平时开发接触最多的估计就是IOC容器,它可以装载bean(所谓的bean也就是我们java中的类,当然也包括servicedao里面),有了这个机制,我们就不用在每次使用这个类的时候为它初始化,很少看到键字new。另外spring的aop,事务管理等等都是我们经常用到的,可见Spring的尤为重要的作用Spring的核心是控制反转(IoC)和面向切面(AOP)

    1.1什么是Spring

    在这里插入图片描述

    肯定有熊dei会问SE/EE开发的一站式框架所谓的一站式是什么意思,(哼,人类,我早就猜到你会问了)
    所谓一站式框架指的是有EE开发的每一层解决方案。

    WEB层 :SpringMVC

    Service层 :Spring的Bean管理,Spring声明式事务

    DAO层 :Spring的Jdbc模板,Spring的ORM模块

    1.2为什么学习Spring

    俗话说,人狠话不多(兄嘚看图)
    在这里插入图片描述

    1.3Spring的版本

    Spring3.x、Spring4.x和Spring5.x

    1.4Spring的体系结构

    正所谓,人狠话不多(兄嘚看图)
    在这里插入图片描述

    2、Spring的入门(IOC)

    2.1什么IOC

    一说起IOC我就想起了武哥对IOC的理解的几个例子,可谓通俗易懂,非常适合刚入门Spring的兄嘚!有兴趣的可以去了解了解武哥,武哥博客:https://blog.csdn.net/eson_15

    IOC(Inverse of Control):控制反转,也可以称为依赖倒置。
    控制反转:将对象的创建权反转给(交给)Spring。

    所谓依赖,从程序的角度看,就是比如A要调用B的方法,那么A就依赖于B,反正A要用到B,则A依

    赖于B。所谓倒置,你必须理解如果不倒置,会怎么着,因为A必须要有B,才可以调用B,如果不倒

    置,意思就是A主动获取B的实例:B b = new B(),这就是最简单的获取B实例的方法(当然还有各种

    设计模式可以帮助你去获得B的实例,比如工厂、Locator等等),然后你就可以调用b对象了。所

    以,不倒置,意味着A要主动获取B,才能使用B;到了这里,就应该明白了倒置的意思了。倒置就是

    A要调用B的话,A并不需要主动获取B,而是由其它人自动将B送上门来。

    2.2通俗理解IOC

    形象的举例就是:
    通常情况下,假如你有一天在家里口渴了,要喝水,那么你可以到你小区的小卖部去,告诉他们,你需要一瓶水,然后小卖部给你一瓶水!这本来没有太大问题,关键是如果小卖部很远,那么你必须知道:从你家如何到小卖部;小卖部里是否有你需要的水;你还要考虑是否开着车去;等等等等,也许有太多的问题要考虑了。也就是说,为了一瓶水,你还可能需要依赖于车等等这些交通工具或别的工具,问题是不是变得复杂了?那么如何解决这个问题呢?
    解决这个问题的方法很简单:小卖部提供送货上门服务,凡是小卖部的会员,你只要告知小卖部你需要什么,小卖部将主动把货物给你送上门来!这样一来,你只需要做两件事情,你就可以活得更加轻松自在:
    第一:向小卖部注册为会员。
    第二:告诉小卖部你需要什么。

    这和Spring的做法很类似!Spring就是小卖部,你就是A对象,水就是B对象
    第一:在Spring中声明一个类:A
    第二:告诉Spring,A需要B

    假设A是UserAction类,而B是UserService类

    <bean id="userService" class="org.leadfar.service.UserService"/>
    <bean id="documentService" class="org.leadfar.service.DocumentService"/>
    <bean id="orgService" class="org.leadfar.service.OrgService"/>
     
    <bean id="userAction" class="org.leadfar.web.UserAction">
         <property name="userService" ref="userService"/>
    </bean>
    

    在Spring这个商店(工厂)中,有很多对象/服务:userService,documentService,orgService,也有很多会员:userAction等等,声明userAction需要userService即可,Spring将通过你给它提供的通道主动把userService送上门来,因此UserAction的代码示例类似如下所示:

    package org.leadfar.web;
    public class UserAction{
         private UserService userService;
         public String login(){
              userService.valifyUser(xxx);
         }
         public void setUserService(UserService userService){
              this.userService = userService;
         }
    }
    
    

    在这段代码里面,你无需自己创建UserService对象(Spring作为背后无形的手,把UserService对象通过你定义的setUserService()方法把它主动送给了你,这就叫依赖注入!),当然咯,我们也可以使用注解来注入。Spring依赖注入的实现技术是:动态代理

    2.3下载Spring的开发包以及解压说明

    官网下载:http://spring.io/
    什么?不会下载?what???
    好吧,已打包好了QAQ:https://pan.baidu.com/s/18wyE-5SRWcCu12iPOX56pg
    什么?没有网盘?what???
    有事请烧香谢谢…

    解压之后,文件说明:
    docs :Spring的开发规范和API
    libs :Spring的开发的jar和源码
    schema :Spring的配置文件的约束

    2.4创建web项目,引入jar包

    在这里插入图片描述

    2.5创建普通接口和实现类

    创建普通接口,定义一个eat方法

    package com.gx.sping;
    
    public interface IUserDao {
    
        public void eat();
    }
    
    

    创建普通实现类

    package com.gx.sping;
    
    public class UserDaoimpl implements IUserDao {
      @Override
        public void eat() {
            // TODO Auto-generated method stub
            System.out.println(用户eat了");
        }
    }
    
    

    2.6Spring的IOC底层实现原理

    创建普通接口和类出现的问题:
    如果底层的实现切换了,需要修改源代码,能不能不修改程序源代码对程序进行扩展?
    重点来了,要想不改变源码,Spring的IOC就能实现!如下图:Spring的IOC底层实现
    在这里插入图片描述

    2.7将实现类交给Spring管理

    1、在classpath下(也就是src)创建一个XML文件

    2、文件名最好统一叫applicationContext.xml

    3、其xml文件的内容头为schema约束

    4、约束文件位置在spring的解压路径下lspring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.htm

    5、不要求xml文件的内容头能够背出来,但要了解的是你要知道它是怎么来的

    6、xml文件的内容头添加后,将实现类交给Spring管理
    在这里插入图片描述
    在这里插入图片描述
    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">
    
     <!-- 实现类UserDaoimpl交给Spring管理 -->
         <bean id="IuserDao" class="com.gx.Ioc.UserDaoimpl" ></bean>
    </beans>
    

    在这里插入图片描述

    2.8编写测试类

    package com.gx.Ioc;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class SpingDemo1 {
        @Test
        public void demo11() {
            // 面向接口传统方式
            UserDaoimpl userdao = new UserDaoimpl();
            userdao.eat();
        }
           //Spring的bean管理方式
        @Test
        public void demo22() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            IUserDao userdao = (IUserDao) applicationContext.getBean("IuserDao");
            userdao.eat();
    
        }
    
    }
    

    兄嘚,如果测试不成功最好看看二者是否对应!!!
    在这里插入图片描述
    兄dei,到这里,Spring的入门(IOC)算是入门了,是不是觉得很有成就感啊?

    拉倒吧! 我都不好意思说了.(兄dei,我错了,是我飘了,呀呀呀,兄dei别打脸鸭QAQ)

    但是我依旧是阻止不了你骄傲的心.

    那就顶我,让我感受感受你的骄傲!哈哈哈QAQ

    2.9 IOC和DI

    IOC不是什么技术,而是一种设计思想,IOC能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制权交给了Spring容器,由容器进行注入组合对象,所以对象与对象之间是松散耦合,这样利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。
    IOC:控制反转,将对象的创建权反转给了Spring。
    DI:依赖注入,前提必须有IOC的环境,Spring管理这个类的时候将类的依赖的属性注入(设置)进来。比如说下面讲到的Spring的属性注入其实就是典型的DI

    所谓继承:is a

    Class A{
    
    }
    Class B extends A{
    
    }
    

    所谓依赖:

    Class A{
    
    }
    Class B{
    	public void xxx(A a){
    
    }
    }
    
    

    所谓聚合:has a

    3、Spring的工厂类

    3.1Spring工厂类的结构

    在这里插入图片描述

    3.2老版本的工厂类:BeanFactory

    BeanFactory:调用getBean的时候,才会生成类的实例。

    3.3新版本的工厂类:ApplicationContext

    ApplicationContext:加载配置文件的时候,就会将Spring管理的类都实例化
    ApplicationContext有两个实现类
    1、ClassPathXmlApplicationContext :加载类路径下的配置文件
    2、FileSystemXmlApplicationContext :加载文件系统下的配置文件

    4、Spring的配置

    4.1XML的提示配置(Schema的配置)

    在XML文件中要使用各种标签来给spring进行配置,博主我这佩奇脑袋怎么可能记住spring中所有的标签呢,不怕不怕,博主我会配置XML的提示配置QAQ,会了这一招就算兄dei你是乔治脑袋也不用担心(再说了我看兄dei各各英俊潇洒,玉树临风,聪明绝顶…咳咳,暴露了暴露了)
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    4.2Bean的相关的配置(< bean >标签的id和name的配置)

    id :使用了约束中的唯一约束。里面不能出现特殊字符的。上面提及到了要与getbean参数值对应

    name :没有使用约束中的唯一约束(理论上可以出现重复的,但是实际开发不能出现的)。里面可以出现特殊字符。

    4.3Bean的生命周期的配置(了解)

    init-method :Bean被初始化的时候执行的方法
    destroy-method :Bean被销毁的时候执行的方法(Bean是单例创建,工厂关闭)
    在这里插入图片描述

    4.4Bean的作用范围的配置(重点)

    scope属性Bean的作用范围

    scope属性值如下(主要用的是前二者)
    singletonscope属性的默认值,Spring会采用单例模式创建这个对象。
    prototype多例模式。(Struts2和Spring整合一定会用到)

    request :应用在web项目中,Spring创建这个类以后,将这个类存入到request范围中。
    session :应用在web项目中,Spring创建这个类以后,将这个类存入到session范围中。
    globalsession :应用在web项目中,必须在porlet环境下使用。但是如果没有这种环境,相对于session。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5、Spring的属性注入

    首先,创建几个普通类

    com.gx.spring.demo.Car
    public class Car {
    	private String name;
    	private Double price;
    	
    	public Car(String name, Double price) {
    		super();
    		this.name = name;
    		this.price = price;
    	}
    	@Override
    	public String toString() {
    		return "Car [name=" + name + ", price=" + price + "]";
    	}
    }
    
    com.gx.spring.demo.Car2
    /**
     * 用作set方法的属性注入类
     */
    public class Car2 {
    	private String name;
    	private Double price;
    	public void setName(String name) {
    		this.name = name;
    	}
    	public void setPrice(Double price) {
    		this.price = price;
    	}
    	@Override
    	public String toString() {
    		return "Car2 [name=" + name + ", price=" + price + "]";
    	}
    	
    }
    
    
    com.gx.spring.demo.Person 
    /**
     * 用作set方法的对象属性注入类
     */
    public class Person {
    	private String name;
    	private Car2 car2;
    	public void setName(String name) {
    		this.name = name;
    	}
    	public void setCar2(Car2 car2) {
    		this.car2 = car2;
    	}
    	@Override
    	public String toString() {
    		return "Employee [name=" + name + ", car2=" + car2 + "]";
    	}
    }
    
    

    5.1构造方法的方式的属性注入

    构造方法的属性注入
    constructor-arg 标签用于配置构造方法的属性注入
    name :参数的名称
    value:设置普通数据
    ref:引用数据,一般是另一个bean id值

    当然了,构造方法的方式的属性注入也支持对象属性的注入,标签中对应属性也是ref
    如果只有一个有参数的构造方法并且参数类型与注入的bean类型匹配,那就会注入到该构造方法中

    applicationContext.xml中配置:

    <!-- 构造方法的方式 -->
    	<bean id="car" class="com.gx.spring.demo.Car">
    		<constructor-arg name="name" value="玛莎拉蒂"/>
    		<constructor-arg name="price" value="800000"/>
    	</bean>
    

    测试方法:

    	/**
    	 * 构造方法方式的普通属性注入方法
    	 */
    	public void demo1(){
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		Car car = (Car) applicationContext.getBean("car");
    		System.out.println(car);
    	}
    

    5.2Set方法的方式的属性注入【开发常用】

    Set方法的普通属性注入
    property 标签用于配置Set方法的属性注入
    name :参数的名称
    value:设置普通数据
    ref:引用数据,一般是另一个bean id值

    applicationContext.xml中配置:

    <!-- set方法的方式 -->
    <bean id="car2" class="com.gx.spring.demo.Car2">
    		<property name="name" value="法拉利黄金跑车"/>
    		<property name="price" value="10000000"/>
    </bean> 
    

    测试方法:

    @Test
    	/**
    	 * set方法方式的属性注入
    	 */
    	public void demo2(){
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		Car2 car2 = (Car2) applicationContext.getBean("car2");
    		System.out.println(car2);
    	}
    

    Set方法设置对象类型的属性
    applicationContext.xml中配置:

    <!-- set方法注入对象类型的属性 -->
    <bean id="Person" class="com.gx.spring.demo.Person">
    			<!-- value:设置普通类型的值,ref:设置其他的类的id或name-->
    		<property name="name" value="涛哥"/>
    		<property name="car2" ref="car2"/>
    	</bean> 
    

    测试方法:

    @Test
    	/**
    	 * set方法注入对象类型
    	 */
    	public void demo3(){
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		Person person= (Person) applicationContext.getBean("Person");
    		System.out.println(person);
    	}
    

    5.3注解的方式属性注入【开发常用】

    @Component (作用在类上通用:组件)
    @Component(“userService”)相当于< bean id=”userService” class=”…”>

    衍生:
    @Controller Web层
    @Service 业务层
    @Repository 持久层
    这三个注解是为了让标注类本身的用途清晰

    属性注入的注解 ( 可以没有set方法
    普通类型属性:@Value

    对象类型属性:@Resource对应bean中的id)= @Autowired(类型)+ @Qualifier(名称)
    在这里插入图片描述

    5.3.1注解的理解

    额,初学框架,注解二字可能对于大部分熊dei来说,太过于陌生,注解其实就是在一个类、方法、属性上,使用@注解名称,就比如是我们最熟悉的接实现口中的方法默认会有一个 @Override (熊dei,这样理解能接受?)
    在这里插入图片描述

    5.3.2注解的jar包导入

    Spring3.x注解的jar包
    在Spring3.x的版本中,使用注解开发,只需要 spring核心基础四包外 + log4j包 + 1个依赖包 即可
    在这里插入图片描述
    Spring4.x注解的jar包
    然而在Spring4.x版本之后则需在 再添加一个要引入 spring-aop 的 jar 包,因为,spring4.x版本中一些注解的依赖方法封装在spring-aop 的 jar 包中
    在这里插入图片描述

    5.3.3引入注解的context约束

    所谓约束就是就是就是约束啦(搽汗),其中bean约束是最基本的约束!(下图也可以看出)
    在这里插入图片描述
    引入约束:(引入 context 的约束):

    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd">
    </beans>
    
    5.3.4编写相关的类
    public interface UserDao {
    public void sayHello();
    }
    public class UserDaoImpl implements UserDao {
    @Override
    public void sayHello() {
    System.out.println("Hello Spring...");
    } }
    
    5.3.5配置注解扫描

    Spring的注解开发:组件扫描(不使用类上注解的时候可以不用组件扫描
    使用注解方式,需要开启组件扫描< context:component-scan base-package=直接包名或者包名.类名/>,当然开发中一般都是base-package=包名,毕竟这样可以扫描整个包,方便开发
    Spring 的注解开发:组件扫描(类上注解: 可以直接使用属性注入的注解)

    <!-- Spring 的注解开发:组件扫描(类上注解: 可以直接使用属性注入的注解) -->
    <context:component-scan base-package="com.gx.spring.demo1"/>
    
    5.3.6 在相关的类上添加注解

    1、使用类上注解方式@Component(value=“userDao”),相当于< bean id="userDao class=“com.gx.类名”>< /bean>
    当然value属性名可以省去直接@Component(“userDao”),当然@Component(“value值任意写建议取的要有意义”)
    2、注解方式可以没有set方法
    在这里插入图片描述

    @Component(value="userDao")  //相当于配置了<bean id="userDao" class="com.gx.UserDaoImpl "></bean>
    public class UserDaoImpl implements UserDao {
    @Override
    public void sayHello() {
    System.out.println("Hello Spring Annotation...");
    } }
    
    5.3.7 编写测试类
    @Test
    public void demo3() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    userDao.sayHello();
    }
    

    5.4P名称空间的属性注入(Spring2.5以后)

    通过引入p名称空间完成属性的注入:
    写法:
    普通属性 p:属性名=”值”
    对象属性 p:属性名-ref=”值”

    P名称空间的约束引入
    在这里插入图片描述
    使用p名称空间
    在这里插入图片描述

    5.5 SpEL的属性注入(Spring3.0以后)

    SpEL:Spring Expression Language,Spring的表达式语言。
    语法: #{SpEL}
    在这里插入图片描述

    5.6集合类型属性注入(了解)

    集合类型属性配置:
    集合的注入都是在< property>标签中添加子标签
    数组:< array >
    List:< list >
    Set:< set >
    Map:< map > ,map存放k/v 键值对,使用描述
    Properties:< props> < prop key="">< /prop>
    普通数据:< value >
    引用数据:< ref >

    	<!-- Spring的集合属性的注入============================ -->
    	<!-- 注入数组类型 -->
    	<bean id="collectionBean" class="com.gx.spring.demo.CollectionBean">
    		<!-- 数组类型 -->
    		<property name="arrs">
    			<list>
    				<value>天才</value>
    				<value>王二</value>
    				<value>冠希</value>
    			</list>
    		</property>
    		
    		<!-- 注入list集合 -->
    		<property name="list">
    			<list>
    				<value>李兵</value>
    				<value>赵如何</value>
    				<value>邓凤</value>
    			</list>
    		</property>
    		
    		<!-- 注入set集合 -->
    		<property name="set">
    			<set>
    				<value>aaa</value>
    				<value>bbb</value>
    				<value>ccc</value>
    			</set>
    		</property>
    		
    		<!-- 注入Map集合 -->
    		<property name="map">
    			<map>
    				<entry key="aaa" value="111"/>
    				<entry key="bbb" value="222"/>
    				<entry key="ccc" value="333"/>
    			</map>
    		</property>
    	</bean>
    

    6、Spring的分模块开发的配置

    分模块配置:
    在加载配置文件的时候,加载多个,没错,这就是传说中的骚操作,堪称开挂级别的操作(当然,这是可以的不是开挂)
    在这里插入图片描述
    在一个配置文件中引入多个配置文件,简直优秀!!!
    在这里插入图片描述
    到这里,恭喜恭喜,各位熊dei以优雅的仪式感闯进Spring世界,对Spring的IOC以及DI有了一定了解了,是不是也很期待Spring的Aop呐,毕竟Spring的核心是控制反转(IOC)和面向切面(AOP)。

    【Spring框架学习二】Spring的AOP通俗理解以及AOP的入门开发(哎哎,别打…别打…别打脸…)

    展开全文
  • 必知必会Spring框架

    2020-05-12 15:22:25
    内容简介: Spring框架是一个开放源代码的J2EE应用程序框架。Spring解决了开发者在J2EE开发中遇到的许多常见的问题,提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序,也可以和Struts等...
  • 手写Spring框架

    万次阅读 多人点赞 2019-01-25 15:30:05
    在学习完Spring框架之后, 我们知道了 Spring容器, IOC, AOP, 事务管理, SpringMVC 这些Spring的核心内容, 也知道了它们底层实现的基本原理, 比如Spring容器就是个Map映射, IOC底层就是反射机制, AOP底层是动态代理, ...
  • Spring框架面试题汇总

    万次阅读 多人点赞 2019-02-19 14:16:45
    1、 简述Spring框架 概念 Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用,但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发,并通过POJO为基础的编程...
  • Java Spring框架 (底层原理+入门)

    千次阅读 多人点赞 2020-07-01 19:55:12
    Java Spring框架 Spring 一、Spring的概述 定义: Spring框架是一个开放源代码的J2EE应用程序框架,由Rod Johnson发起,是针对bean的生命周期进行管理的轻量级容器(lightweight container)。 Spring解决了开发者在...
  • Spring框架依赖jar包

    千次下载 热门讨论 2013-04-06 17:17:07
    Spring框架依赖jar包,其中最小依赖包:org.springframework.core、org.springframework.context、org.springframework.beans、org.springframework.asm、org.springframework.expression、...
  • Spring框架总结【无比详细】

    万次阅读 多人点赞 2018-08-07 15:33:17
    以下内容是我在初学spring时候做的笔记,当时是把比较放在了备忘录里面,如今把笔记重整到csdn上,为了复习也为了分析给大家,笔记写的算比较完整,回看自己做的还是有点羞涩。如有错误之处,欢迎指正,当我日后更...
  • Spring框架常见面试题

    千次阅读 2019-07-07 11:59:13
    1. 你对Spring框架的理解(特点)? Spring框架有哪些模块 ? 问题:你对Spring框架的理解(特点)? Spring框架有哪些模块 ? Spring,一种用来简化企业应用级开发的一种开源框架。 简化开发:它对常用的API做了...
  • Spring是一个开源框架Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的...
  • spring 框架简介与搭建

    万次阅读 2018-03-06 17:10:33
    同时,Spring之所以与Struts、Hibernate等单层框架不同,是因为Spring致力于提供一个以统一的、高效的方式构造整个应用,并且可以将单层框架以最佳的组合揉和在一起建立一个连贯的体系。可以说Spring是一个提供了更...
  • 什么是spring 框架

    千次阅读 2020-07-22 13:55:02
    什么是Spring框架 spring是J2EE应用程序框架,是轻量级的IoC和AOP的容器框架,主要是针对javaBean的生命周期进行管理的轻量级容器,可以单独使用,也可以和Struts框架,ibatis框架等组合使用。 ![在这里插入图片描述...
  • spring框架-认识spring框架(一)

    万次阅读 2019-02-12 20:56:41
    1、Spring定义 2、为什么使用Spring 3、控制反转(IOC) 4、DL (依赖查找) 5、DI(依赖注入) 6、面向切面AOP
  • Spring框架与J2EE框架

    千次阅读 2020-04-28 14:12:59
    Spring框架与J2EE框架 J2EE框架 简介: J2EE的全称是Java 2 Platform Enterprise Edition,它是由SUN公司领导、各厂家共同制定并得到广泛认可的工业标准。 J2EE的体系结构: 客户端层:负责与用户直接交互,...
  • spring5-介绍Spring框架

    万次阅读 2018-09-23 17:56:09
    Spring 框架是一个Java平台,它为开发Java应用程序提供全面的基础架构支持。Spring负责基础架构,因此您可以专注于应用程序的开发。 Spring可以让您从“plain old Java objects”(POJO)中构建应用程序和通过非...
  • Spring框架介绍及使用

    万次阅读 多人点赞 2018-03-17 10:49:54
    Spring框架—控制反转(IOC) 1 Spring框架概述 1.1 什么是Spring 1.2 Spring的优点 1.3 Spring的体系结构 2 入门案例:(IoC) 2.1导入jar包 2.2目标类 2.3 配置文件 2.4测试 3 入门案例:DI 3.1 目标类...
  • Spring框架中都用到了哪些设计模式?

    千次阅读 多人点赞 2019-07-15 18:05:42
    Spring AOP 和 AspectJ AOP 有什么区别? 模板方法 观察者模式 Spring 事件驱动模型中的三种角色 事件角色 事件监听者角色 事件发布者角色 Spring 的事件流程总结 适配器模式 spring AOP中的适配器模式 ...
  • Spring框架深入学习

    2020-01-13 17:07:55
    Spring框架是一个开放源代码的J2EE应用程序框架,由Rod Johnson发起,是针对bean的生命周期进行管理的轻量级容器(lightweight container)。  Spring解决了开发者在J2EE开发中遇到的许多常见的问题,提供了...
  • Spring框架组成

    千次阅读 2019-03-18 10:19:55
    Spring框架技术 Spring是什么 轻量级框架 发布仅单一jar包 非侵入性 容器 管理对象的生命周期,控制对象的创建方式 IOC/DI(控制反转,依赖注入) 配置及管理对象的依赖关系 AOP(面向切面编程) OOP以及...
  • Spring框架有哪些主要模块?

    千次阅读 2020-08-21 08:21:41
    1.Spring Core:Spring框架的核心容器,他提供了Spring框架的基本功能。这个模块中最主要的一个组件为BeanFactory,它使用工厂模式来创建所需的对象。同时BeanFactory使用IOC思想,通过读取XML文件的方式来实例化对象...
  • Spring框架的基本原理分析

    万次阅读 多人点赞 2018-04-05 14:47:07
    工作有一段时间了,工作中基本每个项目都用到了Spring框架,说实话,很多人应该和我一样,只是“使用”了这个框架,对于框架的基本原理应该没怎么研究过。前段时间,和同事交流时,提到了Spring核心组件:IOC(控制...
  • Spring框架的优点、作用 轻量:Spring是轻量级的,基本的版本大小为2MB 控制反转:Spring通过控制反转实现了松散耦合,对象们给出它们的依赖,而不是创建或查找依赖的对象们 面向切面的编程AOP : Spring支持面向切...
  • Spring框架就业精讲课

    2019-03-04 22:38:09
    本课程着重讲解了 IoC、DI思想、Spring测试框架、bean的实例化、作用域、初始化、生命周期、 JDK动态代理和原理、CGLIB动态代理和原理、拦截器思想、AOP思想和开发(传统+AspectJ框架)、Spring对持久层技术支持、声明...
  • JavaWeb学习-Spring框架-1-Spring环境搭建

    千次阅读 2019-06-06 22:46:30
    这篇开始来纪录学习Spring框架的过程,声明一下,什么Struts框架和Hibernate我就不花时间去学习了,现在市场上和公司基本上不用这两个框架了。基本上上Spring和SpringMVC /Spring boot/Spring cloud,然后Mybatis...
  • 如何搭建一个Spring框架超详细

    千次阅读 2020-03-30 11:35:49
    如何搭建一个Spring框架,首先我们要先了解Spring的核心构成部分 1.Spring 的构成 IOC 控制反转 spring 框架最核心的部分 DAO spring 对 访问数据库的支持 MVC spring 对 mvc设计模式的支持 ORM 对象关系映射 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 669,621
精华内容 267,848
关键字:

spring框架

spring 订阅