Spring5

最新推荐文章于 2022-06-01 08:49:55 发布
最新推荐文章于 2022-06-01 08:49:55 发布
阅读量193 收藏
点赞数
分类专栏： JAVA开发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44825185/article/details/118187986
版权

  解决企业开发应用的复杂性。即解决开发企业开发难度，减轻对项目模块之间的管理，类和类之间的管理，帮助开发人员创建对象，管理对象之间的关系。
【总结】Spring 就是一个轻量级的控制反转（IOC）和面向切面（AOP）编程的框架

  • IOC：把之前通过new创建对象的方式交给Spring的xml配置文件或者注解来做
  • AOP：将之前业务功能的扩展实现要改变源代码这一方式解决，不需要改变源代码即可实现功能增强

一、IOC

1.1 IOC本质和理论

【案例结构】
在这里插入图片描述

package com.xxxx.ioc.dao;

public interface userDao {
    void getuse();
}


package com.xxxx.ioc.dao;

public class userDaoImpl implements userDao {
    public void getuse() {
        System.out.println("默认获取用户数据");
    }
}


package com.xxxx.ioc.service;

public interface userService {
    void getService();
}


package com.xxxx.ioc.service;

import com.xxxx.ioc.dao.userDao;
import com.xxxx.ioc.dao.userDaoImpl;
import com.xxxx.ioc.dao.userMysql;

public class userServiceImpl implements userService {
//    传统方法
//    private userDao userdao = new userMysql();
//    ioc:利用set方法进行值的动态注入，传统的方法是程序控制对象的创建再通过业务层的调用实现使用，现在通过set方法
//    将对象的赋值交给用户
    private userDao userdao;

    public void setUserdao(userDao userdao) {
        this.userdao = userdao;
    }

    public void getService() {
//        service层调dao层
        userdao.getuse();
    }
}


import com.xxxx.ioc.dao.userDaoImpl;
import com.xxxx.ioc.dao.userMysql;
import com.xxxx.ioc.service.userService;
import com.xxxx.ioc.service.userServiceImpl;

public class mytest {
    public static void main(String[] args) {
//        1.传统方法
//        测试类相当于servlet
//        会创建service对象
//        userService userservice = new userServiceImpl();
//        userservice.getService();//会输出dao层的方法，service只做一件事：调用dao层
        /*
        * 当增加实现类比如userMysql时，用户想使用新的userMysql时，需要在service层重新获取该实现类对应的对象。
        * 即，美增加一个实现类，用户想要使用时，都需要程序猿在代码出重新调用对应的实现类，如果想解决这个问题，
        * 就需要在serviceimpl中想办法
        * */
//        2. ioc
        userServiceImpl userService = new userServiceImpl();
//        ((userService)userservice).setUserdao(new userMysql());
        userService.setUserdao(new userDaoImpl());
        userService.getService();

    }
}

【总结】
  之前，程序是主动创建对象，控制权在程序员手上，当业务发生扩展，程序员需要更改程序的代码来实现扩展业务的需求。使用set注入后，程序不再具有主动性，而是变成了被动的接收对象，即程序员不用再去管理对象的创建，系统的耦合性大大降低，专注于业务扩展。IOC的控制反转就是说对象创建的控制权的反转。所谓的IOC就是对象由spring来创建，管理和装配

1.2 IOC操作–Bean管理

Bean管理是指俩个操作：一是对象的创建；二是属性的注入。而Bean管理操作方式有俩种：一是xml；二是基于注解方式。

1.2.1 IOC创建对象

1.2.1.1 默认使用无参构造
1.2.1.2 有参构造
  1. 下标赋值
<constructor-arg index="" value=""/>
  1. 类型赋值（不建议使用，容易出错）
<constructor-arg type="" value=""/>
  1. 参数名赋值
<constructor-arg name="" value=""/>

【注意事项】将多个配置文件将通过 < import resource=""/>导入合并为一个

1.2.2 注入属性

  在IOC中，如果要实现属性的注入也就是依赖注入DI，需要在对象创建的基础之上。

1.2.2.1 set注入

  原始的属性注入方式一：使用new创建对象，通过对象调用对应属性的set方法来对属性进行赋值。依赖注入的本质就是set注入。

1.2.2.2 构造器注入

  原始的属性注入方式二：通过有参构造方法在创建对象时进行属性值的注入。

1.2.2.3 其它方式

c命名空间和p命名空间

1.3 Bean的作用域

在这里插入图片描述

1.4 Bean的自动装配

  • 自动装配是spring满足bean依赖的一种方式
  • spring会在上下文中自动寻找，并自动给bean装配属性
    【装配方法】
  1. 在xml中显示的配置
  2. 在java中显示的配置
  3. 隐式的自动装配bean
    通过autowire=""属性来实现自动装配。
    （1）byName:会自动在上下文中寻找和自己对象的set方法后面的值对象的bean的id值
    （2）byType:会自动在上下文中寻找和自己对象属性类型相同的的bean的class值
  4. 使用注解实现自动装配
    【注意事项】
    （1）导入约束
    （2）配置注解支持 < context:annotation-config/ >
    （3）在对应的类添加@autowired
    （4）当有多个对象（id不同class相同）需要自动装配时，除了（3）之外，还需要再添加@qualifier(value=“id值”)
<?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/beans/spring-context.xsd">
    <context:annotation-config/>
</beans>
  1. @autowired和@qualifier是spring下的一套自动装配方法，java包下的@resource不用导包即可实现。如果出现4.（4）的情况，通过添加name属性来解决。

2.6 使用注解开发

在spring4之后，要使用注解开发，必须要确保导入AOP包以及context注解的支持

  1. @Component，放在类上，就相当于bean,如果要赋值可以在set方法上或者属性定义语句上添加@value("")来赋值
  2. @Component的衍生注解，分别是dao层的@@Repository、service层的@Service和controller层的@Controller,这几个注解功能都一样，都代表将某个类装配到spring容器中

2.7 使用java的方式配置Spring

在这里插入图片描述
如果全部使用注解，要使用AnnotationConfigApplicationContext()来获取上下文。

三、AOP

3.1代理模式

代理模式是面向切面编程的底层实现。面试必问【AOP和MVC】
在这里插入图片描述
【代理模式的作用】

  1. 功能增强：在你原有的功能上，增加了额外的功能。新增加的概念叫做功能增强
  2. 控制访问：代理类不让你访问目标，例如商家不让用户访问厂家

【实现的方式】

  1. 静态代理：代理类是自己手工实现的，自己创建一个java类，表示代理类；同时要代理的目标类是确定的。
3.1.1 静态代理

【角色分析】

  1. 抽象角色：一般会使用接口或者抽象类来解决
  2. 真实角色：被代理的角色
  3. 代理角色：代理真实角色
  4. 客户：访问代理对象的人

【代理的好处】

  1. 可以使真实角色的操作更加纯粹
  2. 公共业务交给代理角色，实现业务的分工
  3. 公共业务发生拓展的时候，方便集中管理
    【注意】个人理解，代理和IOC差不多

【代理的缺点】一个真是角色就会产生一个代理角色，代码量翻倍，开发效率变低。
在这里插入图片描述

3.1.2 动态代理
  1. 动态代理和静态代理角色一样
  2. 动态代理的类是动态生成的，不是直接写好的
  3. 动态代理分为两大类，一类是基于接口的动态代理，一类是基于类的动态代理。基于接口的动态代理是基于JDK的动态代理，基于类的是依赖cglib。还有一类是通过java字节码中的javasist来实现的（Jboss服务器）。
基础类：Proxy,InvocationHandler,Method

【Method】

package cn.java_class.agent_class;

import java.lang.reflect.Method;

public class Hellotest1 {
    public static void main(String[] args) throws Exception {
//        普通方法实现使用接口中的实现类的方法是new对象来调用，现在使用反射机制来实现
//        Hello helloimpl = new Helloimpl1();
        Hello helloimpl = new Helloimpl2();
        Method method = Hello.class.getMethod("hello", String.class);
        method.invoke(helloimpl, "张三");

    }
}

【InvocationHandler】
InvocationHandler是一个接口，译为调用处理器，表示你的代理要干什么。有且只有一个方法invoke(),该方法用来表示代理对象要执行的功能代码。即代理类要完成的概念

public Object invoke(Object proxy, Method method, Object[] args)

参数：

  1. Object proxy：jdk创建的代理对象，无需赋值
  2. Method method：目标类中的方法
  3. Object[] args：方法的参数

【Proxy】
通过静态方法newProxyInstance()创建代理对象。

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

参数：

  1. ClassLoader loader：向内存中加载对象
  2. Class<?>[] interfaces：目标对象对应的接口
  3. InvocationHandler h：自己写的代理类要完成的功能
package cn.java_class.agent_class;

public interface Hello {
    public void hello(String name);
}


package cn.java_class.agent_class;

public class Helloimpl1 implements Hello {
    @Override
    public void hello(String name) {
        System.out.println("Helloimpl1你好："+name);
    }
}


package cn.java_class.agent_class;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class handlerdemo1 implements InvocationHandler {
    //被代理的接口
    private Hello hello;

    public void setHello(Hello hello) {
        this.hello = hello;
    }

    //    生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),hello.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(hello, args);
        return result;
    }
}


package cn.java_class.agent_class;

public class Hellotest2 {
    public static void main(String[] args) throws Exception {
        /*
        动态代理的是实现步骤：
        1. 创建接口，定义目标类要完成的功能
        2. 创建目标类实现接口
        3. 创建invocationhandler的实现类，在invoke中完成功能
        * */
        Helloimpl1 h1 = new Helloimpl1();
        handlerdemo1 handlerdemo1 = new handlerdemo1();
        handlerdemo1.setHello(h1);
        Hello proxy = (Hello) handlerdemo1.getProxy();
        proxy.hello("ss"); //运行到这里会跳到handler的invoke方法执行，具体原理没有查到
    }
}

3.2 AOP

3.2.1 概述
  1. 面向切面编程，利用aop对业务逻辑的各个方面进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，提高开发的效率
  2. 通俗的说，AOP就是通过不修改源代码，在主干功能中添加新的功能。
3.2.2 实现方法
  1. 使用spring的API接口
  2. 自定义实现AOP
  3. 使用注解方式

四、Mybatis-Spring

  Mybatis-Spring类会将mybatis无缝整合到spring中，允许mybatis参与到spring的事务管理当中，创建映射器mapper和sqlsession并注入到bean中。要在spring中使用mybatis，必须要在上下文中定义sqlsessionfactory和至少一个数据映射器类。

4.1实现过程

【1.导入依赖】

    <!--    导入依赖-->
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--        spring操作数据库的话还需要一个spring-jdbc的包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

【2.资源过滤配置】

    <!--maven的资源过滤问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

【3.编写对应的配置文件】
  在mybatis中，步骤1定义数据源是写在mybatis-config.xml中的，步骤2-3是封装好的工具类，相当于JDBC中的getConnection。

<?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">

    <!--1. 定义datasource:使用Spring的数据源替换Mabatis的配置（dbcp,c3p0）,我们这里使用spring提供的jdbc-->
    <bean id="owedataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/ssmbuild?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=GMT"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <!--2.创建sqlsessionfactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="owedataSource"/>
        <!--        绑定mybatis的配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/xxxx/mapper/*.xml"/>
    </bean>
    <!--3.创建sqlsession,SqlSessionTemplate就是mybatis中的sqlsession-->
    <bean id="sqlsession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <bean id="bookmapper" class="com.xxxx.mapper.BooksMapperImpl">
        <property name="sqlsession" ref="sqlsession"/>
    </bean>
</beans>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <typeAliases>
        <package name="com.xxxx.pojo"/>
    </typeAliases>

</configuration>

【4.实体类】

package com.xxxx.pojo;

public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;

    public Books() {
    }

    public Books(int bookID, String bookName, int bookCounts, String detail) {
        this.bookID = bookID;
        this.bookName = bookName;
        this.bookCounts = bookCounts;
        this.detail = detail;
    }

    public int getBookID() {
        return bookID;
    }

    public void setBookID(int bookID) {
        this.bookID = bookID;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public int getBookCounts() {
        return bookCounts;
    }

    public void setBookCounts(int bookCounts) {
        this.bookCounts = bookCounts;
    }

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }

    @Override
    public String toString() {
        return "Books{" +
                "bookID=" + bookID +
                ", bookName='" + bookName + '\'' +
                ", bookCounts=" + bookCounts +
                ", detail='" + detail + '\'' +
                '}';
    }
}

【5.mapper】

package com.xxxx.mapper;

import com.xxxx.pojo.Books;

import java.util.List;

public interface BooksMapper {
    List<Books> getAllBooks();
}


package com.xxxx.mapper;

import com.xxxx.pojo.Books;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class BooksMapperImpl implements BooksMapper {
    private SqlSessionTemplate sqlsession;

    public void setSqlsession(SqlSessionTemplate sqlsession) {
        this.sqlsession = sqlsession;
    }

    public List<Books> getAllBooks() {
        BooksMapper mapper = sqlsession.getMapper(BooksMapper.class);
        return mapper.getAllBooks();
    }
}


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--mybatis就是把一个impl实现类变为一个xml的配置文件-->

<mapper namespace="com.xxxx.mapper.BooksMapper">
    <select id="getAllBooks" resultType="books">
        select * from ssmbuild.books;
    </select>
</mapper>

【6.测试类】

import com.xxxx.mapper.BooksMapper;
import com.xxxx.pojo.Books;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class mytest {
    public static void main(String[] args) throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        BooksMapper bookmapper = context.getBean("bookmapper", BooksMapper.class);
        List<Books> allBooks = bookmapper.getAllBooks();
        for (Books allBook : allBooks) {
            System.out.println(allBook);
        }

    }
}
@彼岸花
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring5之maven依赖
chen052210123的专栏
12-02 5589
Maven继承spring-boot-starter-parent。 一、继承以下特性： 1.Java1.8以上 2.UTF-8编码 3.pom.xml上来自spring-boot-dependencies的依赖库可以不用输入<version>标签 4.repackage goal 5.resource filtering 6.plugin配置 7.applicatio...
Spring5全部源码
11-26
想对Spring源码一探究竟的同学可以直接下来阅读，不用去github下，本人也是在阅读Spring源码的时候下载下来的。
了解Spring的变迁从Spring3到Spring5
行天际的博客
11-22 6216
        随着互联网技术的发展，Spring也在不断的进化，从最早轻量级的支持J2EE到现在对高并发，多线程异步程序的支持，spring也不断的更新自己走在技术的最前沿，我们先来从Spring3开始看看spring的发展变迁：  Spring3        Spring4        Spring5   Spring Framework 4.x 和Spring Fra...
Spring5 - 核心原理
小工匠
09-05 1万+
文章目录核心原理解析 核心原理解析 周末梳理了下Spring Framework的核心原理， 详细请参考： 在Processon上，直达地址： https://www.processon.com/view/link/61345766f346fb07155ec9ad
解决spring5与thymeleaf版本冲突的问题
pshdhx的博客
11-29 7390
我的springboot版本是2.2.6.RELEASE 但是我的thymeleaf是这样配置的 <thymeleaf.version>3.0.9.RELEASE</thymeleaf.version> <!-- 布局功能的支持程序 thymeleaf3主程序 layout2以上版本--> <thymeleaf-layout-diclect.version>2.2.2</thymeleaf-layout-dic
【2022年Spring全家桶】Spring5.x 框架详解
ly甲烷的博客
06-01 6993
Spring 框架 IOC(DI) 、AOP、JDBC、事务、日志具体使用方法
《孙哥说Spring5》学习笔记
萌宅鹿的技术小屋
05-24 2万+
这个课比以前看过的Spring5要透彻很多：孙哥说Spring5 工厂设计模式、第一个Spring程序细节分析、整合日志框架 注入详解 — Set注入（JDK内置类型，用户自定义类型）、构造注入（重载） 工厂设计模式、第一个Spring程序细节分析、整合日志框架 对象的生命周期、配置文件参数化、自定义类型转换器、后置处理Bean 每天只能晚上抽空看1个多小时，缓慢学习… ...
【Spring源码学习篇(一)】☀️Spring5本地环境编译，超级实用！！✨
Cocowwy的博客
08-26 1万+
Spring5本地环境编译Spring编译环境的准备Spring环境编译拉取代码修改IDEA的Gradle配置修改maven下载地址Reload All Gradle Projects解决导入报错 org.springframework.cglib.core.*解决导入报错 jdk.jfr.*完成创建新的Moudle Spring编译环境的准备 ⭐️ JDK11 ⭐️ Gradle6.9,1 ⭐️ IDEA2020.3.4 ⭐️【Spring-Framework】5.3.10-SNAPSHOT ✨ JDK/
使用idea和gradle编译spring5源码
热门推荐
baomw的博客
11-11 6万+
写在前面：spring 应该对于每个从事java开发的大兄弟们来说应该都不陌生的，作为一个从业两年多的小开发仔，个人觉得，每天都在面对spring，确从来没有编译过spring源码，有点不太合适。最近在研究spring源码的时候，突然想起编译一下spring源码，网上应该也有很多大神编译过spring源码，在这里我把我再编译过程的遇到的坑，来跟大家分享下。 版本工具：spring5.0.x，gr...
spring5与jdk 版本要求
Rocky balboa
02-09 5134
spring5.0 ** 在 2017 年 9 月发布了它的 GA（通用）版本。该版本是基于 jdk8 编写的， 所以 jdk8 以下版本 将无法使用。 同时，可以兼容 jdk9 版本。      tomcat 版本要求 8.5 及以上 jdk要求jdk8以上 。 注：    我们使用 jdk8 构建工程，可以降版编译。但是不能使用 jdk8 以下版本构建工程。     由于 jdk 和 tomc
Spring5 系统架构
mokingone的专栏
04-28 8537
一，系统架构   Spring 总共大约有 20 个模块，由 1300 多个不同的文件构成。而这些组件被分别整合在核心容器 （Core Container）、AOP（Aspect Oriented Programming）和设备支持（Instrmentation）、 数据访问及集成（Data Access/Integeration）、Web、报文发送（Messaging）、Test，6 个模...
Spring5.pdf
10-07
Spring5
Spring5.zip
08-02
Spring运行helloworld所需的三个基础包，分明为com.springsource.org.apache.commons.logging-1.1.1.jar，spring-beans-5.0.2.RELEASE.jar,spring-core-5.0.2.RELEASE.jar
狂神 Spring5课堂笔记
12-23
Java，Spring笔记
spring 5 recipes
11-05
spring 5 recipes by springer press 2017 very good 非常不错的spring入门资料
JavaScript案例（一）：点击按钮切换图片
weixin_44825185的博客
03-24 1551
代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <script> window.onload = function () { var image = document.getElementById("a"); va
JavaScript（十二）：定时器显示时间
weixin_44825185的博客
03-29 756
代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <style> *{ padding: 0; margin: 0; } </style> </head> <b
JavaScript案例（十）：留言评论功能
weixin_44825185的博客
03-26 706
代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>评论</title> <style> *{ padding: 0; margin: 0; } #out{ width: 512px;
JavaScript案例（三）：大小图切换
weixin_44825185的博客
03-24 410
代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>大小图切换</title> <style> *{ padding: 0; margin: 0; } ul{ list-style: non
spring和spring5
最新发布
03-25
Spring5是Spring框架的最新版本，它引入了许多新特性，包括基于反应式的Spring WebFlux、Java函数式编程接口的支持、响应式数据访问、云原生编程支持等。Spring5同时还增强了Spring Boot的支持，并提供了更简单的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值