Spring入门这一篇就够了

前言

前面已经学习了Struts2和Hibernate框架了。接下来学习的是Spring框架…本博文主要是引入Spring框架…

Spring介绍

Spring诞生:

  • 创建Spring的目的就是用来替代更加重量级的的企业级Java技术
  • 简化Java的开发
    • 基于POJO轻量级和最小侵入式开发
    • 通过依赖注入和面向接口实现松耦合
    • 基于切面和惯例进行声明式编程
    • 通过切面和模板**减少样板式代码 **

侵入式概念

Spring是一种非侵入式的框架

侵入式

  • 对于EJB、Struts2等一些传统的框架,通常是要实现特定的接口,继承特定的类才能增强功能
    • 改变了java类的结构

非侵入式

  • 对于Hibernate、Spring等框架,对现有的类结构没有影响,就能够增强JavaBean的功能

松耦合

前面我们在写程序的时候,都是面向接口编程,通过DaoFactroy等方法来实现松耦合

    private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);    private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);    private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);    private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);

DAO层和Service层通过DaoFactory来实现松耦合

  • 如果Serivce层直接new DaoBook(),那么DAO和Service就紧耦合了【Service层依赖紧紧依赖于Dao】

而Spring给我们更加合适的方法来实现松耦合,并且更加灵活、功能更加强大!—->IOC控制反转

切面编程

切面编程也就是AOP编程,其实我们在之前也接触过…动态代理就是一种切面编程了

当时我们使用动态代理+注解的方式给Service层的方法添加权限.

    @Override    @permission("添加分类")    /*添加分类*/    public void addCategory(Category category) {        categoryDao.addCategory(category);    }    /*查找分类*/    @Override    public void findCategory(String id) {        categoryDao.findCategory(id);    }    @Override    @permission("查找分类")    /*查看分类*/    public List<Category> getAllCategory() {        return categoryDao.getAllCategory();    }    /*添加图书*/    @Override    public void addBook(Book book) {        bookDao.addBook(book);    }
  • Controller调用Service的时候,Service返回的是一个代理对象
  • 代理对象得到Controller想要调用的方法,通过反射来看看该方法上有没有注解
  • 如果有注解的话,那么就判断该用户是否有权限来调用 此方法,如果没有权限,就抛出异常给Controller,Controller接收到异常,就可以提示用户没有权限了。

AOP编程可以简单理解成:在执行某些代码前,执行另外的代码

  • Struts2的拦截器也是面向切面编程【在执行Action业务方法之前执行拦截器】

Spring也为我们提供更好地方式来实现面向切面编程


引出Spring

我们试着回顾一下没学Spring的时候,是怎么开发Web项目的

  • 1. 实体类—>class User{ }
  • 2. daoclass–>  UserDao{  .. 访问db}
  • 3. service—>class  UserService{  UserDao userDao = new UserDao();}
  • 4. actionclass  UserAction{UserService userService = new UserService();}

用户访问:

  • Tomcat->action->service->dao

我们来思考几个问题:

  • ①:对象创建创建能否写死?
  • ②:对象创建细节
    • action    访问时候创建
    • service   启动时候创建
    • dao       启动时候创建
    • action  多个   【维护成员变量】
    • service 一个   【不需要维护公共变量】
    • dao     一个   【不需要维护公共变量】
    • 对象数量
    • 创建时间
  • ③:对象的依赖关系
    • action 依赖 service
    • service依赖 dao

对于第一个问题和第三个问题,我们可以通过DaoFactory解决掉(虽然不是比较好的解决方法)

对于第二个问题,我们要控制对象的数量和创建事件就有点麻烦了….

Spring框架通过IOC就很好地可以解决上面的问题….

IOC控制反转

Spring的核心思想之一:Inversion of Control , 控制反转 IOC

那么控制反转是什么意思呢???对象的创建交给外部容器完成,这个就做控制反转。

  • Spring使用控制反转来实现对象不用在程序中写死
  • 控制反转解决对象处理问题【把对象交给别人创建】

那么对象的对象之间的依赖关系Spring是怎么做的呢??依赖注入,dependency injection.

  • Spring使用依赖注入来实现对象之间的依赖关系
  • 在创建完对象之后,对象的关系处理就是依赖注入

上面已经说了,控制反转是通过外部容器完成的,而Spring又为我们提供了这么一个容器,我们一般将这个容器叫做:IOC容器.

无论是创建对象、处理对象之间的依赖关系、对象创建的时间还是对象的数量,我们都是在Spring为我们提供的IOC容器上配置对象的信息就好了。

那么使用IOC控制反转这一思想有什么作用呢???我们来看看一些优秀的回答…

来自知乎:https://www.zhihu.com/question/23277575/answer/24259844

我摘取一下核心的部分:

ioc的思想最核心的地方在于,资源不由使用资源的双方管理,而由不使用资源的第三方管理,这可以带来很多好处。第一,资源集中管理,实现资源的可配置和易管理第二,降低了使用资源双方的依赖程度,也就是我们说的耦合度

也就是说,甲方要达成某种目的不需要直接依赖乙方,它只需要达到的目的告诉第三方机构就可以了,比如甲方需要一双袜子,而乙方它卖一双袜子,它要把袜子卖出去,并不需要自己去直接找到一个卖家来完成袜子的卖出。它也只需要找第三方,告诉别人我要卖一双袜子。这下好了,甲乙双方进行交易活动,都不需要自己直接去找卖家,相当于程序内部开放接口,卖家由第三方作为参数传入。甲乙互相不依赖,而且只有在进行交易活动的时候,甲才和乙产生联系。反之亦然。这样做什么好处么呢,甲乙可以在对方不真实存在的情况下独立存在,而且保证不交易时候无联系,想交易的时候可以很容易的产生联系。甲乙交易活动不需要双方见面,避免了双方的互不信任造成交易失败的问题。因为交易由第三方来负责联系,而且甲乙都认为第三方可靠。那么交易就能很可靠很灵活的产生和进行了。这就是ioc的核心思想。生活中这种例子比比皆是,支付宝在整个淘宝体系里就是庞大的ioc容器,交易双方之外的第三方,提供可靠性可依赖可灵活变更交易方的资源管理中心。另外人事代理也是,雇佣机构和个人之外的第三方。
==========================update===========================

在以上的描述中,诞生了两个专业词汇,依赖注入和控制反转所谓的依赖注入,则是,甲方开放接口,在它需要的时候,能够讲乙方传递进来(注入)所谓的控制反转,甲乙双方不相互依赖,交易活动的进行不依赖于甲乙任何一方,整个活动的进行由第三方负责管理。

参考优秀的博文①:https://www.tianmaying.com/tutorial/spring-ioc

参考优秀的博文②:这里写链接内容

知乎@Intopass的回答:

  1. 不用自己组装,拿来就用。
  2. 享受单例的好处,效率高,不浪费空间。
  3. 便于单元测试,方便切换mock组件。
  4. 便于进行AOP操作,对于使用者是透明的。
  5. 统一配置,便于修改。

Spring模块

Spring可以分为6大模块:

  • Spring Core  spring的核心功能: IOC容器, 解决对象创建及依赖关系
  • Spring Web  Spring对web模块的支持。
    • 可以与struts整合,让struts的action创建交给spring
    • spring mvc模式
  • Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】
  • Spring ORM  spring对orm的支持:
    • 既可以与hibernate整合,【session】
    • 也可以使用spring的对hibernate操作的封装
  • Spring AOP  切面编程
  • SpringEE   spring 对javaEE其他模块的支持

上面文主要引出了为啥我们需要使用Spring框架,以及大致了解了Spring是分为六大模块的….下面主要讲解Spring的core模块!

Core模块快速入门

搭建配置环境

引入jar包:

本博文主要是core模块的内容,涉及到Spring core的开发jar包有五个

  • commons-logging-1.1.3.jar           日志
  • spring-beans-3.2.5.RELEASE.jar        bean节点
  • spring-context-3.2.5.RELEASE.jar       spring上下文节点
  • spring-core-3.2.5.RELEASE.jar         spring核心功能
  • spring-expression-3.2.5.RELEASE.jar    spring表达式相关表

我主要使用的是Spring3.2版本

编写配置文件:

Spring核心的配置文件applicationContext.xml或者叫bean.xml

那这个配置文件怎么写呢??一般地,我们都知道框架的配置文件都是有约束的…我们可以在spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html找到XML配置文件的约束

<beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:p="http://www.springframework.org/schema/p"    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>   

我是使用Intellij Idea集成开发工具的,可以选择自带的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"></beans>

前面在介绍Spring模块的时候已经说了,Core模块是:IOC容器,解决对象创建和之间的依赖关系

因此Core模块主要是学习如何得到IOC容器,通过IOC容器来创建对象、解决对象之间的依赖关系、IOC细节。

得到Spring容器对象【IOC容器】

Spring容器不单单只有一个,可以归为两种类型

  • **Bean工厂,BeanFactory【功能简单】 **
  • 应用上下文,ApplicationContext【功能强大,一般我们使用这个】

通过Resource获取BeanFactory

  • 加载Spring配置文件
  • 通过XmlBeanFactory+配置文件来创建IOC容器
        //加载Spring的资源文件        Resource resource = new ClassPathResource("applicationContext.xml");        //创建IOC容器对象【IOC容器=工厂类+applicationContext.xml】        BeanFactory beanFactory = new XmlBeanFactory(resource);

类路径下XML获取ApplicationContext

  • 直接通过ClassPathXmlApplicationContext对象来获取
        // 得到IOC容器对象        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");        System.out.println(ac);

在Spring中总体来看可以通过三种方式来配置对象:

  • 使用XML文件配置
  • 使用注解来配置
  • 使用JavaConfig来配置

XML配置方式

在上面我们已经可以得到IOC容器对象了。接下来就是在applicationContext.xml文件中配置信息【让IOC容器根据applicationContext.xml文件来创建对象】

  • 首先我们先有个JavaBean的类
/** * Created by ozc on 2017/5/10. */public class User {    private String id;    private String username;    public String getId() {        return id;    }    public void setId(String id) {        this.id = id;    }    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }}
  • 以前我们是通过new User的方法创建对象的….
    User user = new User();
  • 现在我们有了IOC容器,可以让IOC容器帮我们创建对象了。在applicationContext.xml文件中配置对应的信息就行了
       <!--        使用bean节点来创建对象            id属性标识着对象            name属性代表着要创建对象的类全名        -->    <bean id="user" class="User"/>

通过IOC容器对象获取对象:

  • 在外界通过IOC容器对象得到User对象
        // 得到IOC容器对象        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");        User user = (User) ac.getBean("user");        System.out.println(user);

上面我们使用的是IOC通过无参构造函数来创建对象,我们来回顾一下一般有几种创建对象的方式:

  • 无参构造函数创建对象
  • 带参数的构造函数创建对象
  • 工厂创建对象
    • 静态方法创建对象
    • 非静态方法创建对象

使用无参的构造函数创建对象我们已经会了,接下来我们看看使用剩下的IOC容器是怎么创建对象的。

带参数的构造函数创建对象

首先,JavaBean就要提供带参数的构造函数:

    public User(String id, String username) {        this.id = id;        this.username = username;    }

接下来,关键是怎么配置applicationContext.xml文件了。

    <bean id="user" class="User">        <!--通过constructor这个节点来指定构造函数的参数类型、名称、第几个-->        <constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>        <constructor-arg index="1" name="username" type="java.lang.String" value="zhongfucheng"></constructor-arg>    </bean>

在constructor上如果构造函数的值是一个对象,而不是一个普通类型的值,我们就需要用到ref属性了,而不是value属性

比如说:我在User对象上维护了Person对象的值,想要在构造函数中初始化它。因此,就需要用到ref属性了

    <bean id="person" class="Person"></bean>     <bean id="user" class="User" >        <!--通过constructor这个节点来指定构造函数的参数类型、名称、第几个-->        <constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>        <constructor-arg index="1" name="username" type="java.lang.String" ref="person"></constructor-arg>    </bean>

工厂静态方法创建对象

首先,使用一个工厂的静态方法返回一个对象

public class Factory {    public static User getBean() {        return new User();    }}

配置文件中使用工厂的静态方法返回对象

    <!--工厂静态方法创建对象,直接使用class指向静态类,指定静态方法就行了-->    <bean id="user" class="Factory" factory-method="getBean" >    </bean>

工厂非静态方法创建对象

首先,也是通过工厂的非非静态方法来得到一个对象

public class Factory {    public User getBean() {        return new User();    }}

配置文件中使用工厂的非静态方法返回对象

    <!--首先创建工厂对象-->    <bean id="factory" class="Factory"/>    <!--指定工厂对象和工厂方法-->    <bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>

c名称空间

我们在使用XML配置创建Bean的时候,如果该Bean有构造器,那么我们使用<constructor-arg>这个节点来对构造器的参数进行赋值…

<constructor-arg>未免有点太长了,为了简化配置,Spring来提供了c名称空间…

要想c名称空间是需要导入xmlns:c="http://www.springframework.org/schema/c"

    <bean id="userService" class="bb.UserService" c:userDao-ref="">    </bean>

c名称空间有个缺点:不能装配集合,当我们要装配集合的时候还是需要<constructor-arg>这个节点

装载集合

如果对象上的属性或者构造函数拥有集合的时候,而我们又需要为集合赋值,那么怎么办?

  • 在构造函数上,普通类型
    <bean id="userService" class="bb.UserService" >        <constructor-arg >            <list>                //普通类型                <value></value>            </list>        </constructor-arg>    </bean>
  • 在属性上,引用类型
     <property name="userDao">         <list>             <ref></ref>         </list>     </property>

注解方式

自从jdk5有了注解这个新特性,我们可以看到Struts2框架、Hibernate框架都支持使用注解来配置信息…

通过注解来配置信息就是为了简化IOC容器的配置,注解可以把对象添加到IOC容器中、处理对象依赖关系,我们来看看怎么用吧:

使用注解步骤:

  • 1)先引入context名称空间
    • xmlns:context=”http://www.springframework.org/schema/context”
  • 2)开启注解扫描器
    • <context:component-scan base-package=""></context:component-scan>
    • 第二种方法:也可以通过自定义扫描类以@CompoentScan修饰来扫描IOC容器的bean对象。。如下代码:
//表明该类是配置类@Configuration//启动扫描器,扫描bb包下的    //也可以指定多个基础包    //也可以指定类型@ComponentScan("bb")public class AnnotationScan {}

在使用@ComponentScan()这个注解的时候,在测试类上需要@ContextConfiguration这个注解来加载配置类…

  • @ContextConfiguration这个注解又在Spring的test包下..

创建对象以及处理对象依赖关系,相关的注解:

  • @ComponentScan扫描器
  • @Configuration表明该类是配置类
  • @Component   指定把一个对象加入IOC容器—>@Name也可以实现相同的效果【一般少用】
  • @Repository   作用同@Component; 在持久层使用
  • @Service      作用同@Component; 在业务逻辑层使用
  • @Controller    作用同@Component; 在控制层使用
  • @Resource  依赖关系
    • 如果@Resource不指定值,那么就根据类型来找,相同的类型在IOC容器中不能有两个
    • 如果@Resource指定了值,那么就根据名字来找

测试代码:

  • UserDao
package aa;import org.springframework.stereotype.Repository;/** * Created by ozc on 2017/5/10. *///把对象添加到容器中,首字母会小写@Repositorypublic class UserDao {    public void save() {        System.out.println("DB:保存用户");    }}
  • userService
package aa;import org.springframework.stereotype.Service;import javax.annotation.Resource;//把UserService对象添加到IOC容器中,首字母会小写@Servicepublic class UserService {    //如果@Resource不指定值,那么就根据类型来找--->UserDao....当然了,IOC容器不能有两个UserDao类型的对象    //@Resource    //如果指定了值,那么Spring就在IOC容器找有没有id为userDao的对象。    @Resource(name = "userDao")    private UserDao userDao;    public void save() {        userDao.save();    }}
  • userAction
package aa;import org.springframework.stereotype.Controller;import javax.annotation.Resource;/** * Created by ozc on 2017/5/10. *///把对象添加到IOC容器中,首字母会小写@Controllerpublic class UserAction {    @Resource(name = "userService")    private UserService userService;    public String execute() {        userService.save();        return null;    }}
  • 测试
package aa;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;/** * Created by ozc on 2017/5/10. */public class App {    public static void main(String[] args) {        // 创建容器对象        ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");        UserAction userAction = (UserAction) ac.getBean("userAction");        userAction.execute();    }}

通过Java方式

由于Spring的自动装配并不能将第三方库组件装配到应用中,于是需要显式装配配置。显示装配有两种方式

  • 通过java代码装配bean
  • 通过XML装配bean

Spring In Action作者首推使用自动装配的功能,而后是通过java代码配置bean,最后才用XML文件配置的方式..

那么怎么通过java代码来配置Bean呢??

  • 编写一个java类,使用@Configuration修饰该类
  • 被@Configuration修饰的类就是配置类

编写配置类:

    @org.springframework.context.annotation.Configuration    public class Configuration {    }

使用配置类创建bean:

  • 使用@Bean来修饰方法,该方法返回一个对象。
  • 不管方法体内的对象是怎么创建的,Spring可以获取得到对象就行了。
  • Spring内部会将该对象加入到Spring容器中
  • 容器中bean的ID默认为方法名
@org.springframework.context.annotation.Configurationpublic class Configuration {    @Bean    public UserDao userDao() {        UserDao userDao = new UserDao();        System.out.println("我是在configuration中的"+userDao);        return userDao;    }}
  • 测试代码:要使用@ContextConfiguration加载配置类的信息【引入test包】
package bb;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import org.springframework.test.context.ContextConfiguration;/** * Created by ozc on 2017/5/11. *///加载配置类的信息@ContextConfiguration(classes = Configuration.class)public class Test2 {    @Test    public void test33() {        ApplicationContext ac =                new ClassPathXmlApplicationContext("bb/bean.xml");        UserDao userDao = (UserDao) ac.getBean("userDao");        System.out.println(userDao);    }}

三种方式混合使用

注解和XML配置是可以混合使用的,JavaConfig和XML也是可以混合使用的…

如果JavaConfig的配置类是分散的,我们一般再创建一个更高级的配置类(root),然后使用@Import来将配置类进行组合
如果XML的配置文件是分散的,我们也是创建一个更高级的配置文件(root),然后使用

在JavaConfig引用XML

  • 使用@ImportResource()

在XML引用JavaConfig

  • 使用<bean>节点就行了

bean对象创建细节

在Spring第一篇中,我们为什么要引入Spring提出了这么一些问题:

既然我们现在已经初步了解IOC容器了,那么这些问题我们都是可以解决的。并且是十分简单【对象写死问题已经解决了,IOC容器就是控制反转创建对象】

scope属性

指定scope属性,IOC容器就知道创建对象的时候是单例还是多例的了。

属性的值就只有两个:单例/多例

  • 当我们使用singleton【单例】的时候,从IOC容器获取的对象都是同一个
  • 当我们使用prototype【多例】的时候,从IOC容器获取的对象都是不同的

scope属性除了控制对象是单例还是多例的,还控制着对象创建的时间

  • 我们在User的构造函数中打印出一句话,就知道User对象是什么时候创建了。
    public User() {        System.out.println("我是User,我被创建了");    }
  • 当使用singleton的时候,对象在IOC容器之前就已经创建了
  • 当使用prototype的时候,对象在使用的时候才创建

lazy-init属性

lazy-init属性只对singleton【单例】的对象有效…..lazy-init默认为false….

有的时候,可能我们想要对象在使用的时候才创建,那么将lazy-init设置为ture就行了


init-method和destroy-method

如果我们想要对象在创建后,执行某个方法,我们指定为init-method属性就行了。。

如果我们想要IOC容器销毁后,执行某个方法,我们指定destroy-method属性就行了。

    <bean id="user" class="User" scope="singleton" lazy-init="true" init-method="" destroy-method=""/>

Bean创建细节总结

    /**     * 1) 对象创建: 单例/多例     *  scope="singleton", 默认值, 即 默认是单例 【service/dao/工具类】     *  scope="prototype", 多例;              【Action对象】     *      * 2) 什么时候创建?     *    scope="prototype"  在用到对象的时候,才创建对象。     *    scope="singleton"  在启动(容器初始化之前), 就已经创建了bean,且整个应用只有一个。     * 3)是否延迟创建     *    lazy-init="false"  默认为false,  不延迟创建,即在启动时候就创建对象     *    lazy-init="true"   延迟初始化, 在用到对象的时候才创建对象     *    (只对单例有效)     * 4) 创建对象之后,初始化/销毁     *    init-method="init_user"       【对应对象的init_user方法,在对象创建之后执行 】     *    destroy-method="destroy_user"  【在调用容器对象的destroy方法时候执行,(容器用实现类)】     */

如果文章有错的地方欢迎指正,大家互相交流。

Image placeholder
你在天南星
未设置
  81人点赞

没有讨论,发表一下自己的看法吧

推荐文章
Nginx 配置常用参数,看这一篇就够了

最近在全面学习Nginx,当作笔记了,如有错误,欢迎指出或深入交流。 主模块 #配置用户或者组,默认为nobodynobody。 #userwwwwww; #Nginx开启的worker进程数,

Nginx 配置常用参数,看这一篇就够了

主模块 #配置用户或者组,默认为nobodynobody。 #userwwwwww; #Nginx开启的worker进程数,建议为CPU的核数 #worker_processes2; #指定ngi

了解 MongoDB 看这一篇就够了

作者:美码师一、简介MongoDB是一款流行的开源文档型数据库,从它的命名来看,确实是有一定野心的。MongoDB的原名一开始来自于英文单词”Humongous”,中文含义是指”庞大”,即命名者的意图

侵入式服务治理方案,读这一篇就够

尽管在程序执行效率上,Java不如C、C++,在开发效率、易用性以及学习难度上,Java又不如Ruby、Python、Go,但Java无疑是当今后端系统开发中使用最为广泛的语言。Java所累积的大量生

Carbon —— PHP 中日期 / 时间处理,你只需要这个扩展包就够了

在PHP中使用日期和时间并不是容易或清晰的任务。我们必须处理strtotime,格式化问题,大量计算等等。 这个漂亮的包叫做Carbon可以帮助在PHP开发中处理日期/时间变得更加简单、更语义化,从

Spring-SpringAOP原理,手写Spring事务框架

一、Spring核心知识Spring是一个开源框架,Spring是于2003年兴起的一个轻量级的Java开发框架,由RodJohnson在其著作ExpertOne-On-OneJ2EEDevelopm

SpringBoot个人应用开发框架(SpringBoot版本2.1)+IDEA

前言: 此笔记为本人首个SpringBoot项目框架学习实践记录,期间参考了许多大神的笔记和心得。 参考文档如下: 项目git地址: 一、创建SpringBoot工程 1.1创建父POM工程结

搭建 Spring+SpringMVC+MyBatis 框架

SSM框架整合 pom中添加依赖 添加编辑Spring配置文件 添加编辑SpringMVC配置文件 添加编辑Mybatis配置文件 配置web.xml 1、pom中添加依赖 junit ju

再见 Spring Boot 1.X ,Spring Boot 2.X 走向舞台中心

2019年8月6日,Spring官方在其博客宣布,SpringBoot1.x停止维护,SpringBoot1.x生命周期正式结束。其实早在2018年7月30号,Spring官方就已经在博客进行过预告,

面试问烂的 Spring AOP 原理、SpringMVC 过程

  正文  SpringAOP,SpringMVC,这两个应该是国内面试必问题,网上有很多答案,其实背背就可以。但今天笔者带大家一起深入浅出源码,看看他的原理。以期让印象更加深刻,面试的时候游刃有余。

BAT大牛推荐开发人员必备Spring源码剖析文档,深度剖析Spring

为什么学习读源码我们每天都和代码打交道。经过数年的基础教育和职业培训,大部分程序员都会「写」代码,或者至少会抄代码和改代码。但是,会读代码的并不在多数,会读代码又真正读懂一些大项目的源码的,少之又少。

Spring Boot 中的响应式编程和 WebFlux 入门

Spring5.0中发布了重量级组件Webflux,拉起了响应式编程的规模使用序幕。WebFlux使用的场景是异步非阻塞的,使用Webflux作为系统解决方案,在大多数场景下可以提高系统吞吐量。Spr

秒读 Excel 百万数据(第一篇)

读取前的准备工作 1.文件类型属于.xls、.xlsx,需要用办公软件WPS或Office将文件另存为.csv类型。不能直接重命名修改文件类型,直接重命名修改文件类型会导致数据格式不兼容,Window

一篇文章帮你了解 PHP 7.3 更新

PHP目前依旧是其它脚本语言强劲的竞争对手,这主要归功于其核心维护团队的快速更新。 自从PHP7.0发布以来,社区见证了许多新特性的诞生,极大地改进了开发者在项目中应用PHP的方式。提高PHP应用的性

一篇文章读懂“GAN”——生成式对抗网络

机器学习是一个不断发展的领域,因此对于很多人来说,时刻跟踪这一领域的最新进展是很难的。GAN(生成式对抗网络)是最近引起广泛关注的新兴领域之一,为了让大家能够更好地跟上技术发展的脚步,我们安排了一个简

一篇文章看懂,存储虚拟化在不同用例中的实践与优势

存储虚拟化是一种对物理存储资源进行抽象的技术,使其看起来像是一个集中的资源。虚拟化掩盖了管理内存、网络、服务器和存储中资源的复杂性。存储虚拟化运行在多个存储设备上,使它们看起来就像一个单一的存储池。这

判菜系、调众囗、打分数,这一回,我们用大数据烧菜?

大数据文摘投稿作品作者:blmoistawinde年前,文摘菌曾经扒下了全网所有“年夜饭”菜谱,找到了最有年味的一道菜的一文,对于菜谱数据分析产生了浓厚的兴趣,遂自己也写了个爬虫爬取了某美食网站的一些

助力AWS提升中国市场份额,光环云的这一年

2018年7月1日,光环云数据有限公司(以下简称“光环云”)正式成立。  一个月前,也就是2019年7月1日,光环云刚过完一周岁的生日。目前,云计算已进入到第二阶段,即深水期,第一波互联网、游戏等最容

SpringBoot 集成 JWT 实现 token 验证,token 注销

什么是JWT Jsonwebtoken(JWT),是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准((RFC7519).定义了一种简洁的,自包含的方法用于通信双方之间以JSON对象的形

springboot 多数据源,最简单的整合方式

简介 相信大家有配置过多数据源,或者即将配置多数据的朋友们,会发现网上大概有以下几种方案: 1.使用AOP切片进行动态数据源切换 2.使用MapperScan的basePackages配置不同的map

springDataJpa 最佳实践

springDataJpa最佳实践 前言 SpringDataJpa框架的目标是显著减少实现各种持久性存储的数据访问层所需的样板代码量。SpringDataJpa存储库抽象中的中央接口是Reposit

你知道如何自动保存 Spring Boot 应用进程号吗

1.前言 欢迎阅读SpringBoot2实战系列文章PID对于系统运维来说并不陌生,但是对于一些开发者特别是新手还是要简单介绍一下的。它是ProcessID的简称,是系统分配给一个进程的唯一标识符,

你了解Spring Data JPA的批量插入吗?

实现场景 有关拼团旅游的业务,里面有这样一个逻辑实现:一个拼团活动表Activity对应多个Travel旅游表,travel旅游表要分段存储前端传来的List,Travel表需将每一条数据保存入库,

云端的生存之道,第 1 单元:将 Spring Boot 部署到 Kubernetes

初始化Kubernetes集群 第一步是初始化IBMCloud上的Kubernetes集群。IBMCloud可能需要几分钟时间来启动新的Kubernetes集群;因此,通过先执行初始化操作,可以在后台

云端的生存之道,第 2 单元:将 Spring Boot 应用程序连接到云托管的数据库

前提条件 本系列教程的第1部分,因为本教程直接以第1部分中的课程内容和完成的操作为基础。 一个IBMCloud帐户 云原生数据持久性 IBMCloud提供了许多可持久存储数据的选项。在本教程中,我