精华内容
下载资源
问答
  • java Spring框架的搭建

    2021-03-22 12:49:49
    作为一个基础的开发工具,想必大家都已经下载过Spring框架了。不过光是下载只能得到一个框架,我们还需要对其中进行一些搭建,有点类似于我们在java中常做的变量设置,但又有一些小小的区别。相信说的这里大家已经想...

    54ca31f94ced7a029009746b3a7673d4.png

    作为一个基础的开发工具,想必大家都已经下载过Spring框架了。不过光是下载只能得到一个框架,我们还需要对其中进行一些搭建,有点类似于我们在java中常做的变量设置,但又有一些小小的区别。相信说的这里大家已经想只带具体的Spring搭建方法了,下面就步骤展开讲解。

    1.配置web.xml文件

    xmlns="http://java.sun.com/xml/ns/javaee"

    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

    id="WebApp_ID" version="2.5">

    DispatcherServlet

    org.springframework.web.servlet.DispatcherServlet

    contextConfigLocation

    classpath:applicationContext.xml

    1

    DispatcherServlet

    /

    2.配置applicationContext.xml文件

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:mvc="http://www.springframework.org/schema/mvc"

    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

    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd ">

    3.新建Controller文件package com.zds;

    /**

    * @author zds

    * @date 2018年3月6日

    */

    import org.springframework.web.bind.annotation.RequestMapping;

    import org.springframework.web.bind.annotation.RequestMethod;

    import org.springframework.web.bind.annotation.RequestParam;

    import org.springframework.web.bind.annotation.ResponseBody;

    import org.springframework.web.bind.annotation.RestController;

    @RestController

    @RequestMapping("/test")

    public class TestController {

    @RequestMapping(value = "hello", method = RequestMethod.GET)

    @ResponseBody

    public String helloWorld(@RequestParam("user") String userName) {

    String string = "";

    string.split(",");

    return "Hello " + userName + " !";

    }

    }

    4.把所需要的jar包放入 WEB-INF/lib文件夹中,这些jar包,和这个搭建的项目我都放到这里,如果有兴趣可以去下载。

    5.到这里配置完成,eclipse中把项目添加到tomcat中,启动,浏览器中输入:

    拓展

    Spring核心容器:核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory,它是工厂模式的实现。BeanFactory 使用控制反转 (IOC) 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

    以上就是java Spring框架的搭建,总共分为五个步骤,大家只要根据上方的操作,都不会有太大的问题。学会后赶紧把下载好的Spring框架搭建起来吧。更多Java学习指路:

    展开全文
  • Java Spring 框架详解

    千次阅读 2021-01-11 18:18:02
    文章目录1 Spring入门1.1 Spring 简介1.1.1 Spring的由来1.1.2 Spring的优点1.1.3 Spring的体系结构1.2 Spring 开发环境1.2.1 环境准备1.2.2 创建 Spring 工程1.3 使用IDEA开发 Spring 入门程序2 Spring IoC2.1 ...

    • Spring Bean

    • Spring AOP

    • Spring 事务管理

    1 Spring入门

    1.1 Spring 简介

    1.1.1 Spring的由来

    Spring是一个轻量级Java开发框架,最早有Rod Johnson创建,目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。它是一个分层的JavaSE/JavaEE full-stack(一站式)轻量级开源框架,为开发Java应用程序提供全面的基础架构支持。Spring负责基础架构,因此Java开发者可以专注于应用程序的开发。

    1.1.2 Spring的优点

    (1)方便解耦,简化开发

    Spring就是一个大工厂,可以将所有对象创建和依赖的关系维护,交给Spring管理。

    (2)AOP编程的支持

    Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能。

    (3)声明式事务的支持

    只需要通过配置就可以完成对事务的管理,而无需手动编程。

    (4)方便程序的测试

    Spring对Junit4支持,可以通过注解方便的测试Spring程序。

    (5)方便集成各种优秀框架

    Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架的直接支持(如:Struts、Hibernate、MyBatis等)。

    (6)降低JavaEE API的使用难度

    Spring对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低。

    1.1.3 Spring的体系结构

    Spring框架至今已集成了20多个模块,这些模块分布在核心容器(Core Container)、数据访问/集成(Data Access/Integration)层、Web层、AOP(Aspect Oriented Programming)模块、植入(Instrumentation)模块、消息传输(Messaging)、测试(Test)模块。
    Spring体系结构如下图:
    在这里插入图片描述

    1. 核心容器

    Spring的核心容器是其他模块建立的基础,有Spring-core、Spring-beans、Spring-context、Spring-context-support和Spring-expression(String表达式语言)等模块组成。

    Spring-core模块:提供了框架的基本组成部分,包括控制反转(Inversion of Control,IOC)和依赖注入(Dependency Injection,DI)功能。
    Spring-beans模块:提供了BeanFactory,是工厂模式的一个经典实现,Spring将管理对象称为Bean。
    Spring-context模块:建立在Core和Beans模块的基础之上,提供一个框架式的对象访问方式,是访问定义和配置的任何对象的媒介。ApplicationContext接口是Context模块的焦点。
    Spring-context-support模块:支持整合第三方库到Spring应用程序上下文,特别是用于高速缓存(EhCache、JCache)和任务调度(CommonJ、Quartz)的支持。
    Spring-expression模块:提供了强大的表达式语言去支持运行时查询和操作对象图。这是对JSP2.1规范中规定的统一表达式语言(Unified EL)的扩展。该语言支持设置和获取属性值、属性分配、方法调用、访问数组、集合和索引器的内容、逻辑和算术运算、变量命名以及从Spring的IOC容器中以名称检索对象。它还支持列表投影、选择以及常用的列表聚合。

    1. AOP和Instrumentation

      Spring-aop模块:提供了一个符合AOP要求的面向切面的编程实现,允许定义方法拦截器和切入点,将代码按照功能进行分离,以便干净地解耦。
      Spring-aspects模块:提供了与AspectJ的集成功能,AspectJ是一个功能强大且成熟的AOP框架。
      Spring-instrument模块:提供了类植入(Instrumentation)支持和类加载器的实现,可以在特定的应用服务器中使用。

    2. 消息

    Spring4.0以后新增了消息(Spring-messaging)模块,该模块提供了对消息传递体系结构和协议的支持。

    1. 数据访问/集成

    数据访问/集成层由JDBC、ORM、OXM、JMS和事务模块组成。

    Spring-jdbc模块:提供了一个JDBC的抽象层,消除了烦琐的JDBC编码和数据库厂商特有的错误代码解析。
    Spring-orm模块:为流行的对象关系映射(Object-Relational Mapping)API提供集成层,包括JPA和Hibernate。使用Spring-orm模块可以将这些O/R映射框架与Spring提供的所有其他功能结合使用,例如声明式事务管理功能。
    Spring-oxm模块:提供了一个支持对象/XML映射的抽象层实现,例如JAXB、Castor、JiBX和XStream。
    Spring-jms模块(Java Messaging Service):指Java消息传递服务,包含用于生产和使用消息的功能。自Spring4.1以后,提供了与Spring-messaging模块的集成。
    Spring-tx模块(事务模块):支持用于实现特殊接口和所有POJO(普通Java对象)类的编程和声明式事务管理。

    1. Web

    Web层由Spring-web、Spring-webmvc、Spring-websocket和Portlet模块组成。

    Spring-web模块:提供了基本的Web开发集成功能,例如多文件上传功能、使用Servlet监听器初始化一个IOC容器以及Web应用上下文。
    Spring-webmvc模块:也称为Web-Servlet模块,包含用于web应用程序的Spring MVC和REST Web Services实现。Spring MVC框架提供了领域模型代码和Web表单之间的清晰分离,并与Spring Framework的所有其他功能集成。
    Spring-websocket模块:Spring4.0以后新增的模块,它提供了WebSocket和SocketJS的实现。
    Portlet模块:类似于Servlet模块的功能,提供了Portlet环境下的MVC实现。

    1. 测试

    Spring-test模块支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。

    1.2 Spring 开发环境

    1.2.1 环境准备

    1. JDK
    2. Tomcat
      这里自行下载安装

    1.2.2 创建 Spring 工程

    1. 可以创建maven项目,然后在线导入 Spring 的 jar 包。 在这里插入图片描述
      在这里插入图片描述前提是已安装配置好maven。

    2. 可以使用Idea直接创建Spring项目,这里的jar包自动下载好了。
      在这里插入图片描述
      在这里插入图片描述

    1.3 使用IDEA开发 Spring 入门程序

    1. 使用IDEA创建 Spring 工厂
      在这里插入图片描述
    2. 创建接口TestDao
      Spring 解决的是业务逻辑层和其他层的耦合问题,因此它将面向接口的编程思想贯穿整个系统应用。
      在 src 目录下创建demo1包,并创建接口 TestDao,在定义一个方法 sayHello方法,代码如下:
    package demo1;
    
    public interface TestDao {
        public void sayHello();
    }
    
    
    1. 创建接口的实现类 TestDaoImpl
      在 demo1 包下创建 实现类 TestDaoImpl,代码如下:
    package demo1;
    
    public class TestDaoImpl implements TestDao {
    
        @Override
        public void sayHello() {
            System.out.println("Hello,Spring");
        }
    }
    
    
    1. 创建配置文件 applicationContext.xml
      在 src 目录下创建 Spring 的配置文件 applicationContext.xml,并在该文件使用实现类 TestDaoImpl 创建一个 id 为 testDaoImpl 的Bean,代码如下:
    <?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">
    
    <bean id="testDaoImpl" class="demo1.TestDaoImpl"/>
    
    </beans>
    

    配置文件的名称可以自定义,配置文件信息不需要我们手写,可直接在 Spring 帮助文档复制。

    1. 创建测试类
      在 src 目录下创建一个 Test 的包代码如下:
    package demo1;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            TestDaoImpl testDaoImpl = (TestDaoImpl) classPathXmlApplicationContext.getBean("testDaoImpl");
            testDaoImpl.sayHello();
        }
    }
    
    

    输出结果:
    在这里插入图片描述
    在上述main方法并没有使用new运算符创建TestDaoImpl实例,而是通过 Spring 容器获取实现类的对象,这就是 SpringIoC 的工作机制。

    2 Spring IoC

    2.1 Spring IoC 的基本概念

    控制反转(Inversion of Control,IoC)是一个比较抽象的概念,是Spring框架的核心,用来消除计算机程序的耦合问题。依赖注入(Dependency Injection,DI)是 IoC 的另外一个说法,只是从不同的角度描述相同的概念。下面通过实际生活中的一个例子来解释 IoC 和 DI 。
    当人们需要一件东西时,第一反应就是找东西,例如吃面包。在没有面包店和有面包店两种情况下,您会怎么做?在没有面包店时,最直观的做法可能是您按照自己的口味制作面包,也就是一个面包需要主动制作。然而时至今日,各种网点、实体店盛行,已经没有必要自己制作面包。想吃面包了,去网店或实体店把自己的口味告诉店家,一会就可以吃到面包了。注意,您并没有制作面包,而是由店家制作,但是完全符合您的胃口。
    上面只是列举一个非常简单的例子,但包含了控制反转的思想,即把制作面包的主动权交给店家。下面通过面向对象编程思想继续探讨这两个概念。
    当某个Java对象(调用者,例如您)需要调用另一个Java对象(被调用者,即被依赖对象,例如面包)时,在传统编程模式下,调用者通常会采用“new被调用者”的代码方式来创建对象(例如您自己制作面包)。这种方式会增加调用者与被调用者之间的耦合性,不利于后期代码的升级与维护。
    当Spring框架出现后,对象的实例不再由调用者来创建,而是由Spring容器(例如面包店)来创建。Spring容器会负责控制程序之间的关系(例如面包店负责控制您与面包的关系),而不是由调用者的程序代码直接控制。这样,控制权由调用者转移到Spring 容器,控制权发生了反转,这就是Spring的控制反转。
    从Spring容器角度来看,Spring 容器负责将被依赖对象赋值给调用者的成员变量,相当于为调用者注入它所依赖的实例,这就是Spring的依赖注入。
    综上所述,控制反转是一种通过描述(在Spring中可以是XML或注解)并通过第三方去产生或获取特定对象的方式。在Spring 中实现控制反转的是IoC容器,其实现方法是依赖注入。

    2.2 Spring IoC 容器

    实现控制反转的时 Spring IoC 容器。Spring IoC 容器的设计主要基于BeanFactory 和 ApplicationContext 两个接口。

    2.2.1 BeanFactory

    BeanFactory由org.springframework. beans.factory.BeanFactory接口定义,它提供了完整的IoC服务支持,是一个管理Bean的工厂,主要负责初始化各种Bean。BeanFactory 接口有多个实现类,其中比较常用的是org.springframework .beans factory.xml.XmlBeanFactory,该类会根据XML配置文件中的定义来装配Bean(有关Bean的知识将在第3章讲解)。
    在创建BeanFactory实例时需要提供XML文件的绝对路径。例如可以将第1章chl应用中main 方法的代码修改如下:

    package demo1;
    
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.xml.XmlBeanFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.core.io.FileSystemResource;
    
    public class Test {
        public static void main(String[] args) {
    //        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    //        TestDaoImpl testDaoImpl = (TestDaoImpl) classPathXmlApplicationContext.getBean("testDaoImpl");
    //        testDaoImpl.sayHello();
            BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("applicationContext.xml的绝对路径"));
            TestDaoImpl testDaoImpl = (TestDaoImpl) beanFactory.getBean("testDaoImpl");
            testDaoImpl.sayHello();
        }
    }
    
    

    使用BeanFactory实例加载配置文件在实际开发并不多见,我们只需要了解即可。

    2.2.2 ApplicationContext

    ApplicationContext是 BeanFactory 的子接口,也称应用上下文,由org.springframework.context.ApplicationContext接口定义。ApplicationContext接口包含 BeanFactory 的所有功能外,还添加了对国际化、资源访问、事件传播等内容的支持。
    创建ApplicationContext接口实例通常有以下三种方法:

    1. 通过ClassPathXmlApplicationContext 创建

    ClassPathXmlApplicationContext 将从类路径目录(src根目录)中寻找指定的XML配置文件。
    在这里插入图片描述
    测试代码:

    package demo1;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            TestDaoImpl testDaoImpl = (TestDaoImpl) classPathXmlApplicationContext.getBean("testDaoImpl");
            testDaoImpl.sayHello();
        }
    }
    
    

    这里用的是第一章的配置文件和TestDao,TestDaoImpl。

    1. 通过FileSystemXmlApplicationContext创建

    FileSystemXmlApplicationContext将从配置文件的绝对路径中寻找XML配置文件,找到并装载完成 ApplicationContext 的实例化工作。

    package demo1;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    
    public class Test {
        public static void main(String[] args) {
            FileSystemXmlApplicationContext fileSystemXmlApplicationContext = new FileSystemXmlApplicationContext("ApplicationContext.xml文件的绝对路径");
            TestDaoImpl testDaoImpl = (TestDaoImpl) fileSystemXmlApplicationContext.getBean("testDaoImpl");
            testDaoImpl.sayHello();
        }
    }
    
    

    采用绝对路径的加载方式将导致程序的灵活性变差,一般不推荐使用。因此,通常在 Spring 的 java 应用中采取通过 ClassPathXmlApplicationContext 类来实例化 ApplicationContext 容器的实例化工作将交给Web服务器完成。

    1. 通过Web服务器实例化ApplicationContext 容器

    在Web服务器实例化ApplicationContext 容器时,一般使用基于org.springframework.web.context.ContextLoaderListener 的实现方式(需要将spring-web-5.0.2.RELEASE.jar复制到WEB-INF/lib目录中),此方法只需要在web.xml中添加以下代码:

    <context-param>
    	<!-- 加载src目录下的 applicationContext.xml文件-->
    	<param-name>contextConfigLocation</param-name>
    	<param-value>
    		classpath:applicationContext.xml
    	</param-value>
    </context-param>
    
    <!-- 指定以 ContextLoaderListener 方式启动 Spring 容器 -->
    <listener>
    	<listener-class>
    		org.springframework.web.context.ContextLoaderListener
    	</listener-class>
    </listener>
    

    2.3 依赖注入的类型

    在 Spring 中实现 IoC 容器的方法是依赖注入,依赖注入的作用是在使用 Spring 框架创建对象时动态地将其所依赖的对象(例如属性值)注入 Bean 组件中。Spring 框架的依赖注入通常有两种实现方法,一种是使用构造方法注入,另一种是使用属性的 setter 方法注入。

    2.3.1 使用构造方法注入

    Spring 框架可以采用java的反射机制,通过构造方法完成依赖注入。下面开始代码演示:
    在这里插入图片描述我们在demo2中演示。

    目的:在service 中使用构造方法依赖注入 TestDIDao 接口对象。

    1. 创建 dao 包
      TestDIDao 接口代码如下:
    package demo2.dao;
    
    public interface TestDIDao {
        public void sayHello();
    }
    
    

    TestDIDaoImpl 实现类的代码如下:

    package demo2.dao;
    
    public class TestDIDaoImpl  implements TestDIDao{
        @Override
        public void sayHello() {
            System.out.println("TestDIDao say: hello,Spring!!");
        }
    }
    
    
    1. 创建 service 包
      TestDIService 接口代码如下:
    package demo2.service;
    
    public interface TestDIService {
        public void sayHello();
    }
    
    

    TestDIServiceImpl 实现类的代码如下:

    package demo2.service;
    
    import demo2.dao.TestDIDao;
    
    public class TestDIServiceImpl implements TestDIService {
        private TestDIDao testDIDao;
    	
    	// 构造方法,用于实现依赖注入接口testDIDao
        public TestDIServiceImpl(TestDIDao testDIDao){
            super();
            this.testDIDao = testDIDao;
        }
    
        @Override
        public void sayHello() {
            testDIDao.sayHello();
            System.out.println("TestDIService 构造方法注入say:,hello Spring");
        }
    }
    
    
    1. 编写配置文件
      在demo2包下创建applicationContext.xml文件。在配置文件中首先将TestDIDaoImpl 类托管给 Spring,让Spring 创建其对象,然后service.TestDIServiceImpl 类托管给 Spring,让 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">
    
        <bean id="testDIDaoImpl" class="demo2.dao.TestDIDaoImpl"/>
    
        <bean id="testServiceImpl" class="demo2.service.TestDIServiceImpl">
        	// index = 0 表示 第一个参数为 引用的 testDIDaoImpl
            <constructor-arg index="0" ref="testDIDaoImpl"/>
        </bean>
    
    </beans>
    

    在配置文件中,constructor-arg 元素用于定义构造方法的参数,index 用于定义参数的位置,ref 指定某个实例的引用,如果参数时常量值,ref由value代替。

    1. 创建 Test 类
    package demo2;
    
    import demo2.service.TestDIService;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("demo2/applicationContext.xml");
            TestDIService testServiceImpl = (TestDIService) classPathXmlApplicationContext.getBean("testServiceImpl");
            testServiceImpl.sayHello();
        }
    }
    
    

    输出结果:
    在这里插入图片描述

    2.3.2 使用属性的 setter 方法注入

    使用 setter 方法注入是 Spring 框架中最主流的注入方式,它利用 Java Bean 规范所定义的 setter 方法完成注入,灵活且可读性高。对于 setter 方法注入,Spring 框架也是使用了 Java 的反射机制实现的。下面代码讲解如何使用 setter 方法注入:

    1. 创建接口实现类 TestDIServiceImpl2
      在 TestDIServiceImpl2 中使用属性的 setter 方法依赖注入 TestDIDao 接口对象,具体代码如下:
    package demo2.service;
    
    import demo2.dao.TestDIDao;
    
    public class TestDIServiceImpl2 implements TestDIService {
        private TestDIDao testDIDao;
    
        // 添加 testDIDao 属性的 setter 方法,用于实现依赖注入
        public void setTestDIDao(TestDIDao testDIDao) {
            this.testDIDao = testDIDao;
        }
    
        @Override
        public void sayHello() {
            testDIDao.sayHello();
            System.out.println("TestDIServiceImpl2 : setter 依赖注入");
        }
    }
    
    
    1. 将 TestDIServiceImpl2 类托管给 Spring

      将 TestDIServiceImpl2 类托管给 Spring,让 Spring 创建其对象,同时调用 TestDIServiceImpl2 类的 setter 方法完成依赖注入。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">
    
        <bean id="testDaoImpl" class="demo2.dao.TestDIDaoImpl"/>
    
        <bean id="testServiceImpl" class="demo2.service.TestDIServiceImpl">
            <constructor-arg index="0" ref="testDaoImpl"/>
        </bean>
    
        <bean id="testServiceImpl2" class="demo2.service.TestDIServiceImpl2">
            <property name="testDIDao" ref="testDaoImpl"/>
        </bean>
    
    </beans>
    
    1. 在测试类 Test 中测试:
    package demo2;
    
    import demo2.service.TestDIService;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("demo2/applicationContext.xml");
    
            TestDIService testServiceImpl2 = (TestDIService) classPathXmlApplicationContext.getBean("testServiceImpl2");
            testServiceImpl2.sayHello();
        }
    }
    
    

    输出结果:
    在这里插入图片描述

    3 Spring Bean

    3.1 Bean 的配置

    Spring 可以看作一个大型工厂,用于生产和管理 Spring 容器中的 Bean。如果要使用这个工厂生产和管理 Bean,需要开发者将 Bean 配置在 Spring 的配置文件中。Spring 框架支持 XML 和Properties 两种格式的配置文件,在实际开发中常用 XML 格式的配置文件。
    从前面的学习得知 XML 配置文件的根元素是< beans>,
    < beans>中包含多个< bean>子元素,每个< bean>元素定义一个 Bean,并描述 Bean 如何被装配到 Spring 中。< bean>元素的常用属性及其子元素如下图:

    属性或子元素名称描 述
    idBean 在 BeanFactory中唯一的标识,在代码中通过 BeanFactory 获取 Bean 实例时需要以此作为索引名称
    classBean 的具体实现类,使用类的名(例如:demo1.TestDIDaoImpl)
    scope指定 Bean 实例的作用域,具体在后面讲解
    constructor-arg< bean>元素的子元素,使用构造方法注入,指定构造方法的参数。该元素的 index属性指定参数的序号,ref 属性指定对 BeanFactory 中其他 Bean 的引用关系,type 属性指定参数的类型,value 属性指定参数的常量值
    property< bean>元素的子元素,用于设置一个属性。该元素的name属性指定Bean 实例中相应的属性名称,value 属性指定 Bean 的属性值,ref 属性指定属性对BeanFactory 中其他 Bean 的引用关系
    listproperty元素的子元素,用于封装 List 或数组类型的依赖注入,具体后面介绍(3.5)
    mapproperty元素的子元素,用于封装 Map 类型的依赖注入,具体后面介绍(3.5)
    setproperty元素的子元素,用于封装 Set 类型的依赖注入,具体后面介绍(3.5)
    entrymap元素的子元素,用于设置一个键值对,具体后面介绍(3.5)

    Bean 的配置示例代码如下:

    <?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">
    
        <bean id="testDaoImpl" class="demo2.dao.TestDIDaoImpl"/>
    
        <bean id="testServiceImpl" class="demo2.service.TestDIServiceImpl">
            <constructor-arg index="0" ref="testDaoImpl"/>
        </bean>
    
        <bean id="testServiceImpl2" class="demo2.service.TestDIServiceImpl2">
            <property name="testDIDao" ref="testDaoImpl"/>
        </bean>
    
    </beans>
    

    3.2 Bean 的实例化

    在面向对象编程中,如果想使用某个对象,需要实现实例化该对象。同样,在 Spring 框架中,如果像使用 Spring 容器中的 Bean,也需要实例化 Bean。Spring 框架实例化 Bean 有3种方式,即构造方法实例化、静态工厂实例化和实例工厂实例化(其中,最常用的是构造方法实例化)。

    3.2.1 构造方法实例化

    在 Spring 框架中,Spring 容器可以调用 Bean 对应类中的无参构造方法来实例化 Bean,这种方法称为无参构造方法实例化。下面代码演示过程:

    1. 创建demo3包
      在这里插入图片描述
    2. 创建 BeanClass 类
      在demo3包中创建 BeanClass 类,代码如下:
    package demo3;
    
    public class BeanClass {
        public String messages;
    
        // 无参构造
        public BeanClass(){
            messages = "构造方法实例化Bean";
        }
    
        // 有参构造
        public BeanClass(String s){
            messages = s;
        }
    }
    
    
    1. 创建配置文件
      在demo3包下创建 applicationContext.xml 文件,在配置文件中定义一个 id为 constructorInstance 的 Bean,代码如下:
    <?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">
    
    <bean id="constructorInstance" class="demo3.BeanClass"/>
    
    </beans>
    
    1. 创建测试类
      在demo3包下创建Test类并进行测试,代码如下:
    package demo3;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("demo3/applicationContext.xml");
            BeanClass constructorInstance = (BeanClass) classPathXmlApplicationContext.getBean("constructorInstance");
            System.out.println(constructorInstance + constructorInstance.messages);
        }
    }
    
    

    输出结果:
    在这里插入图片描述我们可以发现它走的是无参构造方法进行实例化。

    3.2.2 静态工厂实例化

    在使用静态工厂实例化 Bean 时要求开发者在工厂类中创建一个静态方法来创建 Bean 的实例。在配置 Bean 时,class 属性指定静态工厂类,同时还需要使用 factory-method 属性指定工厂类中的静态方法。下面通过代码演示:

    1. 创建工厂类 BeanStaticFactory
      在 demo3包中创建 BeanStaticFactory,该类中有一个静态方法来实例化对象,具体代码如下:
    package demo3;
    
    public class BeanStaticFactory {
        private static BeanClass beanInstance = new BeanClass("调用静态工厂方法");
    
        public static BeanClass createInstance(){
            return beanInstance;
        }
    
    
    }
    
    
    1. 编辑demo3包下的配置文件 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">
    
        <bean id="constructorInstance" class="demo3.BeanClass"/>
    
        <!-- 静态工厂方法实例化 Bean,createInstance 为静态工厂类 BeanStaticFactory 中的静态方法   -->
        <bean id="staticFactoryInstance" class="demo3.BeanStaticFactory" factory-method="createInstance"/>
    
    </beans>
    
    1. 编写测试代码:
    package demo3;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("demo3/applicationContext.xml");
    
            BeanClass staticFactoryInstance = (BeanClass) classPathXmlApplicationContext.getBean("staticFactoryInstance");
            System.out.println(staticFactoryInstance + staticFactoryInstance.messages);
        }
    }
    
    

    输出结果如下:
    在这里插入图片描述

    3.2.3 实例工厂实例化

    在使用实例工厂实例化 Bean 时要求开发者在工厂类中创建一个实例方法来创建 Bean 的实例。在配置 Bean 时需要使用 factory-bean 属性指定配置的实例工厂,同时还需要使用 factory-method 属性指定实例工厂中的实例方法。下面通过代码讲解:

    1. 创建工厂类 BeanInstanceFactory
      在demo3包中创建工厂类 BeanInstanceFactory,该类中有一个实例方法来实例对象,代码如下:
    package demo3;
    
    public class BeanInstanceFactory {
        public BeanClass createInstanceFactory(){
            return new BeanClass("调用实例工厂方法实例化 Bean");
        }
    }
    
    
    1. 编辑demo3包下的配置文件 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">
    
        <!-- 配置工厂   -->
        <bean id="myFactory" class="demo3.BeanInstanceFactory"/>
    
        <!-- 使用 factory-bean 属性指定配置工厂,使用 factory-method 属性指定使用工厂中的哪一个方法实例化 Bean   -->
        <bean id="instanceFactoryInstance" factory-bean="myFactory" factory-method="createInstanceFactory"/>
    </beans>
    
    1. 编写测试代码:
    package demo3;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("demo3/applicationContext.xml");
    
    
            BeanClass instanceFactoryInstance = (BeanClass) classPathXmlApplicationContext.getBean("instanceFactoryInstance");
            System.out.println(instanceFactoryInstance+instanceFactoryInstance.messages);
        }
    }
    
    

    输出结果如下:
    在这里插入图片描述

    3.3 Bean 的作用域

    在 Spring 中不仅可以完成 Bean 的实例化,还可以为 Bean 指定作用域。在 Spring 5.0 中为 Bean 的实例定义了如下所示的作用域

    作用域名称描述
    singleton默认的作用域,使用 singleton 定义的 Bean 在 Spring 容器中只有一个 Bean实例
    prototypeSpring 容器每次获取prototype 定义的 Bean,容器都将创建一个新的 Bean 实例
    request在一个 HTTP 请求中容器将返回一个 Bean实例,不同的 HTTP 请求返回不同的 Bean实例。仅在 Web Spring 应用程序上下文中使用
    session在一个 HTTP Session中,容器将返回同一个 Bean 实例。仅在 Web Spring 应用程序上下文中使用
    application为每个 ServletContext 对象创建一个实例,即同一个应用共享一个 Bean 实例。仅在 Web Spring 应用程序上下文中使用
    websocket为每个 WebSocket 对象创建一个 Bean 实例。仅在 Web Spring 应用程序上下文中使用

    3.3.1 singleton作用域

    当将 bean 的 scope 设置为 singleton 时,Spring IoC 容器仅生成和管理一个 Bean 实例。在使用 id 或 name 获取 Bean 实例时,IoC 容器将返回共享的 Bean 实例。
    由于 singleon 时 scope 的默认方式,因此:

     <bean id="constructorInstance" class="demo3.BeanClass"/>
    

     <bean id="constructorInstance" class="demo3.BeanClass" scope="singleton"/>
    

    是等价的。

    测试 singleton 的作用域,代码如下:

    package demo3;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("demo3/applicationContext.xml");
    
            BeanClass constructorInstance = (BeanClass) classPathXmlApplicationContext.getBean("constructorInstance");
            BeanClass constructorInstance2 = (BeanClass) classPathXmlApplicationContext.getBean("constructorInstance");
            System.out.println(constructorInstance);
            System.out.println(constructorInstance2);
    
        }
    }
    
    

    输出结果如下:
    在这里插入图片描述由上图我们可以得知,在使用 id 和 name 获得 Bean 实例时,IoC 容器仅返回一个 Bean 实例。

    3.3.2 prototype作用域

    当将 Bean 的 scope 设置为 prototype 时,Spring IoC 容器将为每次请求创建一个新的实例。将3.3.1中applicationContext.xml配置文件修改如下:

       <bean id="constructorInstance" class="demo3.BeanClass" scope="prototype"/>
    

    测试代码不变,输出结果如下:
    在这里插入图片描述从上图运行结果得知,在使用 id 或 name 两次获取 Bean 实例时,IoC 容器将返回两个不同的 Bean 实例。

    3.4 Bean 的生命周期

    一个对象的生命周期包括创建(实例化与初始化)、使用以及销毁等阶段,在 Spring 中,Bean 对象周期也遵循这一过程, 但是 Spring 提供了许多对外接口,允许开发者对3个过程(实例化、初始化、销毁)的前后做一些操作。 在 Spring Bean 中,实例化是为 Bean 对象开辟空间,初始化则是对属性的初始化。
    Spring 容器可以管理 singleton 作用域 Bean 的生命周期,在此作用域下,Spring 能够精确地知道 Bean 何时被创建,何时初始化完成,以及何时被销毁。而对于 prototype 作用域的 Bean , Spring 只负责创建,当容器创建了 Bean 的实例后,Bean 实例就交给了客户端的代码管理,Spring 容器将不再跟踪其生命周期,并且不会管理那些被配置成 prototype 作用域的 Bean 。Spring 中 Bean 的生命周期的执行是一个很复杂的过程,可借鉴 Servlet 的生命周期“实例化初始化 (init)–>接收请求 (service)–>销毁 (destroy)”来理解 Bean 的生命周期。

    Bean 的生命周期的整个过程如下:
    (1)根据 Bean 的配置情况实例化一个 Bean。
    (2)根据 Spring 上下文对实例化的 Bean 进行依赖注入,即对 Bean 的属性进行初始化。
    (3)如果 Bean 实现了 BeanNameAware 接口,将调用它实现的setBeanName(Stringbeanld) 方法,此处参数传递的是 Spring 配置文件中 Bean 的 id。
    (4)如果 Bean 实现了 BeanFactoryAware 接口,将调用它实现的setBeanFactory 方法,此处参数传递的是当前 Spring 工厂实例的引用。
    (5)如果 Bean 实现了 ApplicationContextAware 接口,将调用它实现的 setApplicationContext(applicationContext)方法,此处参数传递的是 Spring 上下文实例的引用。
    (6)如果 Bean 关联了 BeanPostProcessor 接口,将调用初始化方法postProcessBeforeInitialization(Object obj, String s)对 Bean 进行操作。
    (7)如果 Bean实现了 InitializingBean 接口,将调用 afterPropertiesSet方法。
    (8)如果 Bean在Spring 配置文件中配置了 init-method 属性,将自动调用其配置的初始化方法。
    (9)如果 Bean 关联了 BeanPostProcessor 接口,将调用postProcessAfterlnitializatior(Object obj, String s) 方法,由于是在 Bean初始化结束时调用After方法,也可用于内存或缓存技术。
    注意:以上工作完成后就可以使用该 Bean ,由于该Bean的作用域是singleton,所以调用的是同一个 Bean 实例。
    (10)当 Bean 不再需要时将进入销毁阶段,如果 Bean 实现了DiposableBaen 接口,则调用其实现的destroy方法将 Spring 中的 Bean销毁。
    (11)如果配置文件中通过 destroy-method 属性指定了 Bean 的销毁方法,将调用其配置的销毁方法进行销毁。

    在 Spring 中,通过实现特定的接口或通过< bean> 元素设置可以对 Bean 的生命周期过程产生影响。开发者可以随意地配置< bean> 元素的属性,但不建议过多地使用 Bean 实现接口,因为这样将使代码和 Spring 聚合比较紧密。下面通过实例演示 Bean 的生命周期。

    1. 创建 Bean 的实现类

    在 src 下创建一个 demo4 的包,在此包下创建 BeanLife 类。在 BeanLife类中有两个方法,一个演示初始化过程,一个演示销毁过程。具体代码如下:

    package demo4;
    
    public class BeanLife {
        public void initMyself(){
            System.out.println(this.getClass().getName()+" 执行自定义的初始化方法");
        }
    
        public void destroyMyself(){
            System.out.println(this.getClass().getName()+" 执行自定义的销毁方法");
        }
    }
    
    
    1. 配置 Bean

    在demo4 中创建 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">
    
    
        <!-- 配置 bean,使用 init-method 属性指定初始化方法,使用 destroy-method 属性指定销毁方法  -->
        <bean id="BeanLife" class="demo4.BeanLife" init-method="initMyself" destroy-method="destroyMyself"/>
    
    </beans>
    
    1. 测试生命周期
      在 demo4 中创建 Test 测试类,代码如下:
    package demo4;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
    
            // 为了方便演示销毁方法的执行,这里使用 ClassPathXmlApplicationContext
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("demo4/applicationContext.xml");
    
            System.out.println("获取对象前");
    
            BeanLife beanLife = (BeanLife) classPathXmlApplicationContext.getBean("BeanLife");
    
            System.out.println("获取对象后"+beanLife);
    
            classPathXmlApplicationContext.close();
        }
    }
    
    

    输出结果:
    在这里插入图片描述
    从图中我们可以看出,在加载配置文件时执行了 Bean 的初始化方法 initMyself;在获得对象后,关闭容器时,执行了 Bean 的销毁方法 destroyMyself。

    3.5 Bean 的装配方式

    Bean 的装配可以理解为将 Bean 依赖注入到 Spring 容器中,Bean 的装配方式即 Bean 依赖注入的方式。Spring 容器支持基于 XML 配置的装配、基于注解的装配以及自动装配等多种装配方式,其中最受亲睐的装配方式是基于注解的装配。本章主要讲解基于 XML 配置的装配和基于注解的装配。

    3.5.1 基于 XML 配置的装配

    基于 XML 配置的装配方式已经有很久的历史了,曾经是主要的装配方式。通过 2.3 节的学习,我们知道 Spring 提供了两种基于XML 配置的装配方式,即使用构造方法注入和使用属性的setter方法注入。
    在使用构造方法注入方式装配 Bean时,Bean 的实现类需要提供带参数的构造方法,并在配置文件中使用< bean>元素的子元素< constructor-arg>来定义构造方法的参数;在使用属性的setter方法注入方式装配 Bean时,Bean 的实现类需要提供一个默认无参数的构造方法,并为需要注入的属性提供对应的 setter 方法,另外还需要使用< bean>元素的子元素< property>为每个属性注入值。

    下面通过一个实例来演示基于XML配置的装配方式。

    1. 创建 Bean 的实现类

    在 src 目录下创建 assemble 包,在此包下创建 ComplexUser 类。在ComplexUser 类中分别使用构造方法和使用属性的 setter 方法注入。具体代码如下:

    package assemble;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    public class ComplexUser {
        private String name;
        private List<String> hobbyList;
        private Map<String,String> residenceMap;
        private Set<String> aliasSet;
        private String[] array;
    
    
        // 无参构造,setter 方法注入时需要用到。
        public ComplexUser() {
            super();
        }
    
        // 有参构造,构造器方法注入时需要用到。
        public ComplexUser(String name, List<String> hobbyList, Map<String, String> residenceMap, Set<String> aliasSet, String[] array) {
            this.name = name;
            this.hobbyList = hobbyList;
            this.residenceMap = residenceMap;
            this.aliasSet = aliasSet;
            this.array = array;
        }
    
        /**
         * 属性的 set 方法
         */
        public void setName(String name) {
            this.name = name;
        }
    
        public void setHobbyList(List<String> hobbyList) {
            this.hobbyList = hobbyList;
        }
    
        public void setResidenceMap(Map<String, String> residenceMap) {
            this.residenceMap = residenceMap;
        }
    
        public void setAliasSet(Set<String> aliasSet) {
            this.aliasSet = aliasSet;
        }
    
    
        public void setArray(String[] array) {
            this.array = array;
        }
    
    
        @Override
        public String toString() {
            return "ComplexUser{" +
                    "name='" + name + '\'' +
                    ", hobbyList=" + hobbyList +
                    ", residenceMap=" + residenceMap +
                    ", aliasSet=" + aliasSet +
                    ", array=" + Arrays.toString(array) +
                    '}';
        }
    }
    
    
    1. 配置 Bean
      在 Spring 配置文件中使用 ComplexUser 配置 Bean 的两个实例,具体代码如下:
    <?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">
    
        <!-- 使用构造方法注入   -->
        <bean id="user1" class="assemble.ComplexUser">
            <constructor-arg index="0" value="wdf"/>
            <constructor-arg index="1">
                <list>
                    <value>唱歌</value>
                    <value>爬山</value>
                    <value>玩游戏</value>
                </list>
            </constructor-arg>
            <constructor-arg index="2">
                <map>
                    <entry key="dalian" value="大连"/>
                    <entry key="beijing" value="北京"/>
                    <entry key="shanghai" value="上海"/>
                </map>
            </constructor-arg>
            <constructor-arg index="3">
                <set>
                    <value>wdf100</value>
                    <value>wdf101</value>
                    <value>wdf102</value>
                </set>
            </constructor-arg>
            <constructor-arg index="4">
                <array>
                    <value>aaa</value>
                    <value>bbb</value>
                </array>
            </constructor-arg>
    
        </bean>
    
        <!--  使用 setter 方法注入  -->
        <bean id="user2" class="assemble.ComplexUser">
            <property name="name" value="wdf2"/>
            <property name="hobbyList">
                <list>
                    <value>看书</value>
                    <value>学习</value>
                </list>
            </property>
            <property name="residenceMap">
                <map>
                    <entry key="shenzhen" value="深圳"/>
                    <entry key="tianjin" value="天津"/>
                </map>
            </property>
            <property name="aliasSet">
                <set>
                    <value>wdf104</value>
                    <value>wdf105</value>
                </set>
            </property>
            <property name="array">
                <array>
                    <value>cccc</value>
                    <value>dddd</value>
                </array>
            </property>
        </bean>
    </beans>
    
    1. 测试基于 XML 配置的装配方式
      具体代码如下:
    package assemble;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("assemble/applicationContext.xml");
            // 使用构造方法装配
            ComplexUser user1 = (ComplexUser) classPathXmlApplicationContext.getBean("user1");
    
            // 使用 setter 方法装配
            ComplexUser user2 = (ComplexUser) classPathXmlApplicationContext.getBean("user2");
    
            System.out.println(user1);
            System.out.println(user2);
        }
    }
    
    

    输出结果如下:

    在这里插入图片描述

    3.5.2 基于注解的装配

    在 Spring 框架中,尽管使用 XML 配置文件可以简单地装配 Bean,但如果应用中有大量的 Bean 需要装配,会导致 XML 配置文件过于庞大,不方便以后的升级与维护,因此更多的时候推荐开发者使用注解(annotation)的方式去装配 Bean。
    在 Spring 框架中定义了一系列的注解,下面介绍几种常用的注解。

    一 、@Component
    该注解是一个泛化的概念,仅仅表示一个组件对象(Bean),可以作用在任何层次上。下面通过一个实例讲解@Component。

    1. 创建 Bean的实现类

    在 src 目录下创建 annotation 包,在该包下创建 Bean 的实现类 AnnotationUser,代码如下:

    package annotation;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    @Component()
    /**
     * 相当于把 id 为 annotationUser 的 Bean 注册到 Spring 容器中。
     */
    public class AnnotationUser {
    
        @Value("wdf") // 只能注入简单的值,对于复杂的值目前使用该方法还解决不了
        private String name;
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }
    
    
    1. 配置注解
      现在有了 Bean 的实现类,但不能进行测试,因为 Spring 容器并不知道去哪里扫描 Bean 对象,需要在配置文件中配置注解,在annotation包下创建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"
           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-3.0.xsd">
    	 <!-- 扫描annotation包下的注解 -->
        <context:component-scan base-package="annotation"/>
    
    </beans>
    
    1. 测试 Bean 实例
      测试代码如下:
    package annotation;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("annotation/applicationContext.xml");
            AnnotationUser annotationUser = (AnnotationUser) classPathXmlApplicationContext.getBean("annotationUser");
            System.out.println(annotationUser.getName());
        }
    }
    
    

    输出结果:
    在这里插入图片描述

    注:在 Spring 4.0以上的版本,配置注解指定包中的注解进行扫描前需要实现导入 Spring AOP 的 JAR 包 spring-aop-5.0.2.RELEASE.jar

    二、@Repository
    该注解用于将数据访问层(DAO)的类表示为 Bean,即注解数据访问层 Bean,其功能与@Component 相同。
    三、@Service
    该注解用于标注一个业务逻辑组件类(Service层),其功能与@Component 相同。
    四、@Controller
    该注解标注一个控制器组件类(Spring MVC 的 Controller),其功能与@Component 相同。
    五、@Autowired
    该注解可以对类成员变量、方法及构造方法进行标注,完成自动装配的工作。通过使用@Autowired 来消除 setter 和 getter 方法。默认按照 Bean 的类型进行装配。
    六、@Resource
    该注解与@Autowired 的功能一样,区别在于该注解默认是按照名称来装配注入的,只有当找不到名称匹配的 Bean 时才会按照类型来装配注入;而@Autowired 默认按照 Bean 的类型进行装配,如果想按照名称来装配注入,则需要和@Qualifier 注解一起使用
    @Resource 注解有两个属性,name和type。name 属性指定 Bean 实例名称,即按照名称来装配注入;type 属性指定 Bean 的类型,即按照 Bean 的类型进行装配。
    七、@Qualifier
    该注解与 @Autowired 注解配合使用。当@Autowired 注解需要按照名称来装配注入时需要和该注解一起使用,Bean 的实例名称由@Qualifier 注解的参数指定。
    在上面几个注解中,虽然@Repository、@Service和@Controller 等注解的功能与@Component 注解相同,但为了使类的标注更加清晰(层次化),在实际开发中推荐使用@Repository 标注数据访问层(DAO层)、使用@Service 标注业务逻辑层(Service 层)、使用@Controller 标注控制器层(控制层)。
    下面通过一个实例讲解如何使用这些注解:

    1. 创建DAO层
      在 src 中创建 annotation.dao 包,在该包下创建 TestDao 接口和 TestDaoImpl实现类,并将实现类 TestDaoImpl 使用 @Repository 注解标注为数据访问层。

    TestDao 的代码如下:

    package annotation.dao;
    
    public interface TestDao {
        public void save();
    }
    
    

    TestDaoImpl 的代码如下:

    package annotation.dao;
    
    import org.springframework.stereotype.Repository;
    
    @Repository("testDaoImpl")
    // 相当于@Repository,但如果在 service 层使用@Resource(name=”testDaoImpl“), testDaoImpl 不能省略
    public class TestDaoImpl implements TestDao {
        @Override
        public void save() {
            System.out.println("testDao save");
        }
    }
    
    
    
    1. 创建 Service 层
      在 src 中创建 annotation.service 包,在该包下创建 TestService 接口和 TestServiceImpl 实现类,并将实现类 TestServiceImpl 使用@Service 注解标注为业务逻辑层。
      TestService 的代码如下:
    package annotation.service;
    
    public interface TestService {
        public void save();
    }
    
    

    TestServiceImpl 的代码如下:

    package annotation.service;
    
    import annotation.dao.TestDao;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    @Service("testServiceImpl")
    // 相当于@Service
    public class TestServiceImpl implements TestService {
    
        @Resource(name = "testDaoImpl")
        private TestDao testDao;
    
        @Override
        public void save() {
            testDao.save();
            System.out.println("testService save");
        }
    }
    
    
    1. 创建 Controller 层:
      在 src 中创建 annotation.controller 包,在该包下创建 TestController 类,并将 TestController 类使用@Controller 注解标注为控制层。

    TestController 的代码如下:

    package annotation.controller;
    
    import annotation.service.TestService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class TestController {
    
        @Autowired
        private TestService testService;
    
        public void save(){
            testService.save();
            System.out.println("testController save");
        }
    }
    
    
    1. 配置注解
    <?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: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-3.0.xsd">
        <!-- 扫描annotation包下的注解 -->
        <context:component-scan base-package="annotation"/>
    
    </beans>
    
    1. 测试
    package annotation.service;
    
    import annotation.controller.TestController;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class test {
        public static void main(String[] args) {
            ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("annotation/applicationContext.xml");
            TestController testController = (TestController) classPathXmlApplicationContext.getBean("testController");
            testController.save();
        }
    }
    
    

    输出结果:
    在这里插入图片描述

    4 Spring AOP

    Spring AOP 是 Spring 框架体系结构中非常重要的功能模块之一,该模块提供了面向切面编程实现。面向切面编程在事物处理、日志记录、安全控制等操作中被广泛使用。本章将对 Spring AOP 的相关概念及实现进行详细讲解。

    4.1 Spring AOP 的基本概念

    4.1.1 AOP 的概念

    AOP (Aspect-Oriented Programming)即面向切面编程,它与OOP( Object-OrientedProgramming,面向对象编程)相辅相成,提供了与 OOP 不同的抽象软件结构的视角。在 OOP 中,以类作为程序的基本单元,而 AOP 中的基本单元是Aspect(切面)。Struts2 的拦截器设计就是基于 AOP 的思想,是个比较经典的应用。
    在业务处理代码中通常有日志记录、性能统计、安全控制、事务处理、异常处理等操作。尽管使用 OOP 可以通过封装或继承的方式达到代码的重用,但仍然有同样的代码分散在各个方法中。因此,采用 OOP 处理日志记录等操作不仅增加了开发者的工作量,而且提高了升级维护的困难。为了解决此类问题,AOP 思想应运而生。AOP 采取横向抽取机制,即将分散在各个方法中的重复代码提取出来,然后在程序编译或运行阶段将这些抽取出来的代码应用到需要执行的地方。这种横向抽取机制采用传统的 OOP 是无法办到的,因为 OOP 实现的是父子关系的纵向重用。但是 AOP 不是 OOP 的替代品,而是 OOP 的补充,它们相辅相成。
    在 AOP 中,横向抽取机制的类与切面的关系:
    在这里插入图片描述

    4.1.2 AOP 的术语

    在 Spring AOP 框架中涉及以下常用术语。

    1. 切面
      切面(Aspect)是指封装横切到系统功能(例如事物处理)的类。

    2. 连接点
      连接点(Joinpoint)是指程序运行中的一些时间点,例如方法的调用或异常的抛出。

    3. 切入点
      切入点(Pointcut)是指需要处理的连接点。在 Spring AOP 中,所有的方法执行都是连接点,而切入点是一个描述信息,他修饰的是连接点,通过切入点确定哪些连接点需要被处理。切面、连接点和切入点的关系如下:
      在这里插入图片描述

    4. 通知
      通知(Advice)是由切面添加到特定的连接点(满足切入点规则)的一段代码,即在定义好的切入点处所要执行的程序代码,可以将其理解为切面开启后切面的方法,因此通知是切面的具体实现。

    5. 引入
      引入(Introduction)允许在现有的实现类中添加自定义的方法和属性。

    6. 目标对象
      目标对象(Target Object)是指所有被通知的对象。如果 AOP 框架使用运行时代理的方式(动态的 AOP)来实现切面,那么通知对象总是一个代理对象。

    7. 代理
      代理(Proxy)是通知应用到目标对象之后被动态创建的对象。

    8. 织入
      织入(Weaving)是将切面代码插入到目标对象上,从而生成代理对象的过程。根据不同的实现技术,AOP 织入有 3 中方式;编译器织入,需要由特殊的 Java 编译器;类装载期织入,需要有特殊的类装载器;动态代理织入,在运行期为目标类添加通过生成子类的方式。Spring AOP 框架默认采用动态代理织入,而 AspectJ(基于 Java 语言的 AOP框架)采用编译期织入和类装载期织入。

    4.2 动态代理

    在 Java 中有很多动态代理技术,例如 JDK、CGLIB、Javassist、ASM,其中最常用的动态代理技术是 JDK 和 CGLIB。目前,在 Spring AOP 中常用 JDK 和 CGLIB 两种动态代理技术。

    4.2.1 JDK 动态代理

    JDK 动态代理是 java.lang.reflect.*包提供的方式,它必须借助一个接口才能产生代理对象,因此,对于使用业务接口的类,Spring 默认使用 JDK 动态代理实现 AOP。下面通过一个实例演示如何使用 JDK 动态代理实现 Spring AOP,具体步骤如下:

    注:这里我们使用maven工程,其好处是导入jar包时十分方便。

    1. 安装 maven
    2. 配置 maven
    3. 使用 Idea 创建 maven工程
      在这里插入图片描述一直点下一步就可以。

    在pom 文件添加相关依赖

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.feng</groupId>
        <artifactId>Spring2</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
      
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.2.3.RELEASE</version>
            </dependency>
        </dependencies>
    
    </project>
    

    把 src 目录删掉,我们在其中创建 Module。
    在这里插入图片描述

    在这里插入图片描述创建 JDK module,子目录中的 pom 会继承父目录的 pom。
    在这里插入图片描述

    1. 我们在 JDK module 的 src 目录下创建 dynamic.jdk 包,在该包创建接口 TestDao 和接口实现类 TestDaoImpl。该实现类作为目标类,在代理类中对其方法进行增强处理。

    TestDao 的代码如下:

    package dynamic.jdk;
    
    public interface TestDao {
        public void save();
    
        public void modify();
    
        public void delete();
    }
    
    

    TestDaoImpl 的代码如下:

    package dynamic.jdk;
    
    public class TestDaoImpl implements TestDao {
    
        public void save() {
            System.out.println("保存");
        }
    
    
        public void modify() {
            System.out.println("修改");
        }
    
    
        public void delete() {
            System.out.println("删除");
        }
    }
    
    
    1. 创建切面类
      在 JDK module 的 dynamic.jdk 目录下创建切面类 MyAspect,注意在该类中可以定义多个通知(增强处理的功能方法)
      MyAspect 的代码如下:
    package dynamic.jdk;
    
    public class MyAspect {
        public void check(){
            System.out.println("模拟权限控制");
        }
    
        public void except(){
            System.out.println("模拟异常处理");
        }
    
        public void log(){
            System.out.println("模拟日志");
        }
    }
    
    
    1. 创建代理类
      在 dynamic.jdk 包中创建代理类 JDKDynamicProxy。在 JDK 动态代理类必须实现 java.lang.reflect.InvocationHandler 接口,并编写代理方法,在代理方法中需要通过 Proxy 实现动态代理。

    JDKDynamicProxy 的代码如下:

    package dynamic.jdk;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class JDKDynamicProxy implements InvocationHandler {
    
        // 声明目标类接口对象(真实对象)
        private TestDao testDao;
    
        // 创建代理的方法,建立代理对象和真实对象的代理关系,并返回代理对象
        public Object createProxy(TestDao testDao){
            this.testDao = testDao;
    
            // 类加载器
            ClassLoader cld = JDKDynamicProxy.class.getClassLoader();
    
            // 被代理对象实现的所有接口
            Class[] classes = testDao.getClass().getInterfaces();
    
            // 使用代理类进行增强,返回代理后的对象
            return Proxy.newProxyInstance(cld,classes,this);
        }
    
    
        /**
         * 代理的逻辑对象
         * @param proxy 被代理的对象
         * @param method 将要执行的方法
         * @param args 执行方法时需要的参数
         * @return 返回代理结果
         * @throws Throwable
         */
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
            // 创建一个切面
            MyAspect myAspect = new MyAspect();
    
            // 前增强
            myAspect.check();
            myAspect.except();
    
            // 在目标类上调用方法并传入参数,相当于调用 testDao中的方法
            Object obj = method.invoke(testDao,args);
    
            // 后增强
            myAspect.log();
            
            return obj;
        }
    }
    
    
    
    1. 创建测试类
      在test.java 包下创建Test类进行测试:
    
    import dynamic.jdk.JDKDynamicProxy;
    import dynamic.jdk.TestDao;
    import dynamic.jdk.TestDaoImpl;
    
    public class Test {
        public static void main(String[] args) {
            // 创建代理对象
            JDKDynamicProxy jdkDynamicProxy = new JDKDynamicProxy();
    
            // 创建目标对象
            TestDao testDao = new TestDaoImpl();
    
            // 从代理对象中获取增强后的目标对象,该对象是一个被代理的对象,它会进入代理的逻辑方法 invoke中
            TestDao testDaoAdvice = (TestDao) jdkDynamicProxy.createProxy(testDao);
    
            // 执行方法
            testDaoAdvice.save();
            System.out.println("-----------");
            testDaoAdvice.modify();
            System.out.println("-----------");
            testDaoAdvice.delete();
            System.out.println("-----------");
    
    
    
        }
    }
    
    

    运行结果如下:
    在这里插入图片描述

    4.2.2 CGLIB

    从 4.2.1 节可知,JDK 动态代理必须提供接口才能使用,对于没有提供接口的类,只能采用 CGLIB 动态代理。
    CGLIB(Code Generation Library)是一个高性能开源的代码生成包,采用非常底层的字节码技术,对指定的目标生成一个子类,并对子类进行增强。在 Spring Core 包中已经集成了 CGLIB 所需要的 jar 包。下面通过一个实例演示:

    1. 创建 CGLIB module

    2. 创建目标类
      在 CGLIB module 下创建 dynamic.cglib包,在该包下创建 TestDao。
      TestDao 的代码如下:

    package dynamic.cglib;
    
    public class TestDao {
    
    
        public void save() {
            System.out.println("保存");
        }
    
        public void modify() {
            System.out.println("修改");
        }
    
        public void delete() {
            System.out.println("删除");
        }
    
    }
    
    
    1. 创建代理类
      在 dynamic.cglib 包下创建代理类 CglibDynamicProxy,该类实现 MethodInterceptor 接口。
      CglibDynamicProxy 的代码如下:
    package dynamic.cglib;
    
    
    import dynamic.jdk.MyAspect;
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    public class CglibDynamicProxy implements MethodInterceptor {
        public Object createProxy(Object target){
            // 创建一个动态类对象,即增强类对象
            Enhancer enhancer = new Enhancer();
    
            // 确定需要增强的类,设置其父类
            enhancer.setSuperclass(target.getClass());
    
            // 确定代理逻辑对象为当前对象,要求当前对象实现 MethodInterceptor 的方法
            enhancer.setCallback(this);
    
            // 返回创建的代理对象
            return enhancer.create();
        }
    
    
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            // 创建一个切面
            MyAspect myAspect = new MyAspect();
            
            // 前增强
            myAspect.check();
            myAspect.except();
    
            // 目标方法执行,返回代理结果
            Object obj = methodProxy.invokeSuper(o,objects);
    
            // 后增强
            myAspect.log();
    
            return obj;
        }
    }
    
    
    

    注:这里的切面我们还是用的 JDK 代理时用到的切面

    1. 创建测试类
      具体代码如下:
    package dynamic.cglib;
    
    public class Test {
        public static void main(String[] args) {
            // 创建代理对象
            CglibDynamicProxy cdp = new CglibDynamicProxy();
    
            // 创建目标对象
            TestDao testDao = new TestDao();
    
            // 获取增强后的目标对象
            TestDao proxy = (TestDao) cdp.createProxy(testDao);
    
            // 执行方法
            proxy.delete();
            System.out.println("---------");
            proxy.save();
            System.out.println("---------");
            proxy.modify();
            System.out.println("---------");
        }
    
    }
    
    

    输出如下:在这里插入图片描述

    4.3 基于代理类的 AOP 实现

    从 4.2 节可知,在 Spring 中默认使用 JDK 动态代理实现 AOP 编程。使用 org.springframework.aop.framework.ProxyFactoryBean 创建代理是 Spring AOP 实现的基本方式。

    一、通知类型
    在讲解 ProxyFactoryBean 之前先了解以下 Spring 的通知类型。根据 Spring 中通知在目标类方法的连接点位置,通知可以分为 6 中类型。

    1. 环绕通知
      环绕通知实在目标方法执行前和执行后实施增强,可应用于日志记录、事物处理等功能。

    2. 前置通知
      前置通知是在目标方法执行前实施增强,可应用于权限管理等功能。

    3. 后置返回通知
      后置返回通知是在目标方法成功执行后实施增强,可应用于关闭流、删除临时文件等功能。

    5 Spring 事务管理

    展开全文
  • 元素1456.2.5元素146习题148实验6动态SQL完成单表的修改和查询操作148第7章关联映射1497.1一(多)对一的关联操作1497.2一对多的关联操作1547.2.1一对多关联操作示例1557.2.2影响关联操作性能的相关配置1587.3多对多...

    元素145

    6.2.5元素146

    习题148

    实验6用动态SQL完成单表的修改和查询操作148

    第7章关联映射149

    7.1一(多)对一的关联操作149

    7.2一对多的关联操作154

    7.2.1一对多关联操作示例155

    7.2.2影响关联操作性能的相关配置158

    7.3多对多的关联操作161

    7.4MyBatis的缓存机制166

    7.4.1一级缓存(SqlSession级别)166

    7.4.2二级缓存(mapper级别)168

    习题171

    实验7表的关联操作171

    第8章MyBatis的注解开发175

    8.1常用注解175

    8.2单表的操作176

    8.3一对多的双向关联操作180

    8.4多对多的关联操作184

    8.5注解中的动态SQL186

    习题189

    实验8基于注解的开发189

    第9章SSM框架整合191

    9.1基于MyBatis映射文件的整合开发191

    9.1.1创建Web项目191

    9.1.2编写配置文件193

    9.1.3创建映射文件与接口197

    9.1.4创建Service及其实现类198

    9.1.5创建 Controller202

    9.1.6创建JSP页面203

    9.1.7运行程序204

    9.2基于MyBatis注解的整合开发204

    9.2.1创建Web项目205

    9.2.2编写配置文件205

    9.2.3创建接口与注解205

    9.2.4创建Service及其实现类209

    9.2.5创建 Controller212

    9.2.6创建JSP页面213

    9.2.7运行程序215

    习题216

    实验9SSM整合开发216

    0章项目案例: 作业管理系统217

    10.1系统简介217

    10.1.1系统用例图217

    10.1.2系统功能框图217

    10.2系统设计219

    10.2.1数据库设计219

    10.2.2实体类的设计222

    10.2.3系统结构设计226

    10.3系统环境的搭建227

    10.3.1所需JAR包227

    10.3.2创建数据库228

    10.3.3创建Web项目232

    10.4功能模块实现237

    10.4.1教师管理模块237

    10.4.2班级管理模块264

    10.4.3学生管理模块272

    10.4.4课程管理模块289

    10.4.5习题管理模块296

    10.4.6作业管理模块310

    10.4.7批改作业模块330

    10.4.8学生端作业管理模块340

    10.5单元测试357

    10.6发布运行系统358

    参考文献360

    展开全文
  • Spring是干什么的,Spring能做什么,Spring框架的简介spring 关键是要理解他的思想,依赖注入和切面编程。注入就是把所有的东西交给spring管理,给你生产对象。像hibernate,struts,自己的对象都可以交给spring管理...

    Spring是干什么的,Spring能做什么,Spring框架的简介

    spring 关键是要理解他的思想,依赖注入和切面编程。

    注入就是把所有的东西交给spring管理,给你生产对象。像hibernate,struts,自己的对象都可以交给spring管理。

    切面就相当于一个在一个汉堡中间可以加肉片,可以加个鸡蛋等材料,相当于不要去每个代码里面都去加。像日志可、数据权限和一些通用的业务处理都可以用切面做。

    要是新手的话建议你买本书看看,多看些例子来理解他的这种思想。并且试着自己动手来实现这些思想。

    42f1eebffdf5c50877894779a60ca5f7.gif

    一个完整的J2ee理想搭配方案是

    webwork2.2(MVC)   +   Spring(IoC,   AOP,   事务处理)   +   Hibernate(ORM)   +   Acegi(安全系统)   +   XFire(web   service)   /   Hessian(远程服务)

    Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。 Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器。然而,这仅仅是完整图景中的一部分:Spring在使用IoC容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。 Spring提供了唯一的数据访问抽象,包括简单和有效率的JDBC框架,极大的改进了效率并且减少了可能的错误。Spring的数据访问架构还集成了Hibernate和其他O/R mapping解决方案。Spring还提供了唯一的事务管理抽象,它能够在各种底层事务管理技术,例如JTA或者JDBC事务提供一个一致的编程模型。Spring提供了一个用标准Java语言编写的AOP框架,它给POJOs提供了声明式的事务管理和其他企业事务–如果你需要–还能实现你自己的aspects。这个框架足够强大,使得应用程序能够抛开EJB的复杂性,同时享受着和传统EJB相关的关键服务。Spring还提供了可以和IoC容器集成的强大而灵活的MVC Web框架。

    开心洋葱 , 版权所有丨如未注明 , 均为原创丨未经授权请勿修改 , 转载请注明java的Spring是干什么的,Spring能做什么,Spring框架的简介!

    展开全文
  • 做为一个合格的Java开发人员,你一定听说过Spring框架,虽然会应用,但却未必能够深入理解框架的原理,只是像其它人一样,泛泛的只是停留在理解的层面。小编会带着大家一步步了解Spring框架。struts:web层,比较...
  • 毫无疑问,Spring Framework是最受欢迎的Java框架之一,通过提供依赖注入和控制反转等特性,可以轻松创建真实的企业级Java应用程序。但是,Spring不仅是一个DI和IOC框架。通过提供有用的抽象层,它可以简化许多Java ...
  • spring:通过控制反转IOC和依赖注入DI来解耦(说白话就是不让到处瞎new对象)spring系列框架的优点:方便解耦、简化开发、支持AOP切面、声明事务支持、方便测试、方便集成其他优秀框架、低侵入spring mvc:servlet来...
  • 轻量级的Java 开发框架 Spring

    千次阅读 2021-02-12 10:39:17
    Spring是一个开源框架Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的...
  • 前言spring技术可以说是java企业开发里最重要的技术,不过真的理解spring的作用和意义还真是一件麻烦的事情,很多人对spring理解其实都是停留在使用阶段(例如:声明式事务很好用等等),当今的spring技术生态环境里...
  • 一、Spring Security介绍spring security 是基于 spring 的安全框架。它提供全面的安全性解决方案,同时在 Web 请求级和方法调用级处理身份确认和授权。在 Spring Framework 基础上,spring security 充分利用了依赖...
  • 分享给大家供大家参考,具体如下:前言虽然之前Spring,但是今天试着去搭建依然遇到了困难,而且上网找教程,很多写的是在web里使用Spring ..本文实例讲述了Java Spring开发环境搭建及简单入门示例。分享给大家...
  • Spring框架简介

    2021-02-26 13:07:03
    Spring是一个开源框架,为了解决企业级应用开发的复杂性而创建的。Spring中的组件(也称为bean或JavaBean)并不需要满足JavaBean规范,可以是任何形式的POJO(Plain Old Java Object)。Spring简化Java开发的四种策略:...
  • Maven是 Apache 下的一个纯 Java 开发的开源项目。基于项目对象模型(缩写:POM)概念,Maven利用一个中央信息片断能管理一个项目的构建、报告和文档等步骤。 Maven 也可被用于构建和管理各种项目,例如 C#,Ruby,...
  • 一、使用注解标识组件 二、组件扫描 1、普通扫描 2、包含与排除特定组件 (1)扫描包含特定组件 (2)扫描排除特定组件 3、实现注解的三步骤 三、组件自动装配 1、@autowired注解 (1)@autowired装配原理 ...
  • Spring框架的优点

    2021-02-28 18:02:43
    Spring框架的优点Spring是一...轻量Spring框架使用的jar都比较小,一般在1M以下或者几百kb。Spring核心功能的所需的jar总共在3M左右。Spring框架运行占用的资源少,运行效率高。不依赖其他jar针对接口编程,解耦合S...
  • 我是Spring的新手。 谁能让我知道SpringSpring MVC Framework有什么区别?Spring是一个很大的框架,其中包含许多组件。...1- Spring用抽象的词是一个框架The Spring Framework is an open source application f...
  • Spring是什么,是什么Java框架Spring是什么Spring是一个开源框架Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson创建。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源...
  • java面试题spring框架

    2021-03-06 04:25:05
    java面试题spring框架Spring是一个提供了更完善开发环境的一个框架,可以为POJO(Plain Old Java Object)对象提供企业级的服务。下面是spring框架面试时的常见问题:1.什么是Spring?Spring是一个开源的Java EE开发...
  • spring框架是干什么的

    千次阅读 2021-03-10 06:24:37
    Spring框架是一个开源的轻量级Java开发应用框架,用于简化企业级应用程序开发使用Spring可以:根据配置文件创建及组装对象之间的依赖关系;无耦合的实现日志记录,性能统计,安全控制;和第三方框架无缝集成,方便...
  • Spring框架引入

    2021-03-15 11:11:00
    Struts与Hibernate可以做什么事?Struts,Mvc中控制层解决方案可以进行...Spring框架基于Struts与Hibernate的mvc模式进行项目开发;思考:1. 对象创建创建能否写死?2. 对象创建细节对象数量action 多个 【维护成员...
  • Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson创建。...完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。...
  • 回顾:Spring框架发展史

    千次阅读 2021-03-06 00:17:48
    相信经历过不使用框架开发 Web 项目的老 Java 程序员都会比较有感触,如今的程序员开发项目太轻松了,基本只需要关心业务如何实现,通用技术问题只需要集成框架便可,免去了很多重复琐碎的配...
  • 一、概述1、什么是Spring SecuritySpring Security是一个安全框架2、相对于Shiro的优缺点优点Spring Security基于Spring开发,权限更加方便,功能更强大、社区资源更丰富、可以和Spring Boot,Spring Cloud无缝集成...
  • Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。 然而,Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言,绝大部分Java...
  • Spring 框架漏洞集合

    千次阅读 2021-03-11 17:00:54
    虽说是Spring框架漏洞,但以下包含并不仅Spring Framework,Spring Boot,还有Spring Cloud,Spring Data,Spring Security等。CVE-2010-1622 Spring Framework class.classLoader类远程代码执行影响版本:...
  • Java开发中常用框架

    2021-02-12 17:29:48
    1Java开发中常用框架Java 编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言。下面小编给大家说说Java开发中常用框架,希望能对你有些帮助。一、SpringSpring...
  • 1.1 手绘 Spring 架构脑图 1.2 手绘 Spring5 架构脑图 1.3 手绘 Spring Security 架构脑图 1.4 手绘 Spring Boot 架构脑图 1.5 手绘Spring Cloud 架构脑图 1.6 手绘Spring MVC 架构脑图 第二篇:面试篇 2.1 ...
  • 利用Spring这种框架可以简化编程过程中许多基本的工作,在配置好之后就可以方便地构建业务应用,当然,也不能使用太多框架多了会把代码逻辑弄得很麻烦,重写或调用起来都有局限性。 Spring是当前流行框架之一,...
  • 本篇文章给大家带来的内容是...一、Spring开源框架的简介Spring是一个开源框架,也是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作《Expert One-On-One J2EE Development and Design》中阐述的...
  • Java EE框架整合开发入门到实战:Spring+Spring MVC+MyBatis(微课版)(从入门到实战·微课视频)详细讲解了Java EE中SpringSpring MVC和MyBatis三大框架(SSM)的基础知识和实际应用。为了更好地帮助读者学习SSM框架,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 327,752
精华内容 131,100
关键字:

java用spring框架开发网站

java 订阅
spring 订阅