Spring Framework 学习笔记1：基础

最新推荐文章于 2024-09-15 21:05:54 发布
最新推荐文章于 2024-09-15 21:05:54 发布
阅读量93 收藏
点赞数
分类专栏： JAVA 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hy6533/article/details/132599135
版权

Spring Framework 学习笔记1：基础

1.简介

1.1.生态和发展史

关于 Spring 的生态和发展史，可以观看这个视频。

1.2.系统架构

关于 Spring 的系统架构，可以观看这个视频。

2.Ioc

Spring 的核心概念是 Ioc （Inversion Of Control），它的目的是降低代码的耦合度，让对象不再由用户创建，而是由 Ioc 容器（Ioc Container）来创建和管理。

这里用一个简单示例说明 Spring 如何通过 Ioc 思想来对对象创建进行解耦。

这个项目结构很简单：

├─src
│  ├─main
│  │  ├─java
│  │  │  └─cn
│  │  │      └─icexmoon
│  │  │          └─springdemo
│  │  │              │  Application.java
│  │  │              │
│  │  │              ├─dao
│  │  │              │  │  UserDao.java
│  │  │              │  │
│  │  │              │  └─impl
│  │  │              │          UserDaoImpl.java
│  │  │              │
│  │  │              └─service
│  │  │                  │  UserService.java
│  │  │                  │
│  │  │                  └─impl
│  │  │                          UserServiceImpl.java
│  │  │
│  │  └─resources
│  └─test
│      └─java

项目中的各种对象之间的依赖都是直接用new创建的：

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
    @Override
    public void save(){
        System.out.println("UserServiceImpl.save() is called.");
        userDao.save();
    }
}

入口类也是简单的new了一个 Service 并执行具体方法：

public class Application {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        userService.save();
    }
}

虽然这里实现类都有对应的接口，我们也都使用接口进行调用，但具体实现类的创建是用new，这种耦合是无法避免的。假设我们要用另一个 UserDao 的实现来替换当前实现：

public class UserDaoImpl2 implements UserDao {
    @Override
    public void save() {
        System.out.println("UserDaoImpl2.save() is called.");
    }
}

就必须修改 UserService 的实现类中相应的 new 语句：

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl2();
    // ...
}

下面我们看 Spring 是如何做的。

2.1.依赖

首先需要添加 Spring Framework 的依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.0.10</version>
</dependency>

2.2.Spring Bean Definition

由 Ioc 容器创建和管理的对象被称作 Spring Bean，我们需要“告诉” Spring 框架需要创建哪些 Spring Bean 以及如何创建。具体来说需要用一个 XML 作为 Spring Bean 的定义文件（Spring Bean Definition）。

通过 Idea 在 Resource 目录下创建一个 application.xml 作为 Spring Bean 的定义文件。

添加 spring-context 依赖后，Idea 的创建 XML Configuration File 菜单中会出现一个子菜单 Spring Config，该菜单可以添加一个 Spring 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">
        
</beans>

按需要添加 Spring 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="userService" class="cn.icexmoon.springdemo.service.impl.UserServiceImpl"/>
    <bean id="userDao" class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl"/>
</beans>

bean 节点的id属性指定 Bean 名称，class属性指定 Bean 类型。

2.3.Ioc 容器

接下来要创建 Ioc 容器，并用 Ioc 容器加载 Bean 定义，然后通过容器来获取对象。

public class Application {
    public static void main(String[] args) {
        //创建 IOC 容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.save();
    }
}

2.4.依赖注入

现在入口类中实现了 Ioc，但 UserServiceImpl 中依然用 new 的方式创建依赖对象：

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl2();
	// ...
}

如果一个 Spring Bean 依赖的对象是另一个 Spring Bean，我们可以通过 Spring Bean 定义告诉 Spring 它们之间的依赖关系，并由 Spring 自动完成相应的依赖创建，这种方式叫做依赖注入（DI，Dependency Injection）。

在这个示例中，现在userService和userDao都已经被定义为 Spring Bean，所以可以：

<bean id="userService" class="cn.icexmoon.springdemo.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
</bean>
<bean id="userDao" class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl"/>

property标签说明了userService Bean 中的userDao属性对应的另一个 Bean 是userDao。

如果你用的是 Idea，应该可以注意到此时property的 name 属性是标红的，因为 Spring 需要使用 set 方法实现依赖注入，所以我们还要为其添加一个 set 方法：

public class UserServiceImpl implements UserService {
    @Setter
    private UserDao userDao;
    // ...
}

当然，现在不需要使用new了。

这里我使用 Lombok 添加 set 方法，需要添加相关的 Lombok 依赖，这里不再赘述。

现在已经将对象创建进行了解耦，如果我们要使用UserDaoImpl2作为实现而非UserDaoImpl，只需要修改 Bean 定义即可，不需要修改代码：

<bean id="userDao" class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl2"/>

3.Spring Bean

3.1.生命周期

Spring Bean 有生命周期，我们可以利用一些生命周期回调在 Bean 的特定阶段执行代码。

在 UserDao 中定义两个方法，分别代表在 Bean 创建后和 Bean 销毁前需要执行的回调方法：

public class UserDaoImpl2 implements UserDao{
	// ...
    public void afterConstruct(){
        System.out.println("UserDaoImpl2 has constructed.");
    }

    public void beforeDestroyed(){
        System.out.println("UserDaoImpl2 will be destroyed.");
    }
}

要让这两个方法生效，还必须在 Bean 定义中告诉 Spring 这两个方法是生命周期回调方法：

<bean id="userDao"
      class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl2"
      init-method="afterConstruct"
      destroy-method="beforeDestroyed"/>

如果实际运行程序，你会发现beforeDestroyed方法并不会被执行。

这是因为主程序执行完毕后，Java 虚拟机会直接进行垃圾回收，并不会通知 Ioc 容器，Ioc 容器自然也不会调用相应 Bean 的“销毁前回调方法”。

解决这个问题有两种方式，第一种是主动关闭 Ioc 容器：

public class Application {
    public static void main(String[] args) {
        //创建 IOC 容器
        ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.save();
        // 关闭 IOC 容器
        ctx.close();
    }
}

需要注意的是，通常使用的 Ioc 接口ApplicationContext并没有close方法，所以这里必须使用一个上层接口ConfigurableApplicationContext作为引用。

第二种方式是将 Ioc 容器注册到 Java 虚拟机，这样 Java 虚拟机在程序执行完进行垃圾回收时就会通知 Ioc 容器，Ioc 容器自然就可以完成包括 Bean 生命周期回调之类的清理工作：

public class Application {
    public static void main(String[] args) {
        // 创建 IOC 容器
        ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        // 注册关闭钩子
        ctx.registerShutdownHook();
        UserService userService = (UserService) ctx.getBean("userService");
        userService.save();
    }
}

除了在 Bean 定义中指定生命周期方法外，还可以实现生命周期回调的相关接口：

public class UserDaoImpl2 implements UserDao, InitializingBean, DisposableBean {
	// ...
    @Override
    public void destroy() throws Exception {
        System.out.println("UserDaoImpl2 will be destroyed.");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("UserDaoImpl2 has constructed.");
    }
}

这样做就不再需要 XML 中定义相关回调方法：

<bean id="userDao"
      class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl2"/>

3.2.作用域

Bean 有作用域，默认是单例（Singleton）。也就是说用同一个名称（或类型）从 Ioc 容器中获取到的会是同一个 Bean 实例：

public class Application {
    public static void main(String[] args) {
        // ...
        UserService userService = (UserService) ctx.getBean("userService");
        UserService userService2 = (UserService) ctx.getBean("userService");
        String equalResult = userService == userService2 ? "是同一个对象" : "不是同一个对象";
        System.out.println(equalResult);
        userService.save();
    }
}

可以在 Bean 定义中改变这一点：

<bean id="userService"
      class="cn.icexmoon.springdemo.service.impl.UserServiceImpl"
      scope="prototype">
    <property name="userDao" ref="userDao"/>
</bean>

现在 userService Bean 的作用域是原型（Prototype），即每次获取都会产生一个新的实例。

如果是 Web 开发，还会有其他作用域，比如request等。

3.3.实例化

3.3.1.构造器

一般情况下，Spring Bean 是通过无参构造器实现的实例创建：

public class UserServiceImpl implements UserService {
	// ...
    public UserServiceImpl() {
        System.out.println("UserServiceImpl's constructor is called.");
    }
}

运行程序后可以看到这个构造器被 Ioc 容器调用并产生输出。

当然，一般并不需要我们显式创建无参构造器，一个类没有任何构造器时会有一个默认的无参构造器。

3.3.2.静态工厂

有时候，对于一些需要复杂初始化逻辑的对象，我们会使用工厂模式进行创建。在 Spring 中，同样可以用工厂模式创建 Bean 实例。

假设有一个用于创建 UserDao 实例的静态工厂：

public class UserDaoFactory {
    public static UserDao createUserDao(){
        System.out.println("UserDaoFactory.createUserDao() is called.");
        return new UserDaoImpl2();
    }
}

在 Bean 定义中我们不再使用具体的类型创建 userDao，而是改为使用静态工厂：

<bean id="userDao"
      class="cn.icexmoon.springdemo.dao.factory.UserDaoFactory"
      factory-method="createUserDao"/>

这里的class是工厂类，factory-method是具体创建 Bean 实例的方法。

3.3.3.实例工厂

并非所有的工厂模式都是静态工厂，有一些会使用实例工厂。即工厂类本身有一些状态属性，需要先创建工厂类的实例，再用工厂实例创建目标对象。

假设有这样一个工厂类：

public class UserDaoFactory2 {
    public UserDao createUserDao(){
        System.out.println("UserDaoFactory2.createUserDao() is called.");
        return new UserDaoImpl2();
    }
}

此时就需要将工厂实例也定义为 Spring Bean，然后用这个工厂实例完成目标 Bean 实例的创建：

<bean id="userDao"
    factory-bean="userDaoFactory2"
    factory-method="createUserDao"/>
<bean id="userDaoFactory2" class="cn.icexmoon.springdemo.dao.factory.UserDaoFactory2"/>

3.4.依赖注入

3.4.1.Setter 注入

之前在 Ioc 中介绍过通过 set 方法完成依赖注入。这种方式也叫做 Setter 注入，除了可以用 Setter 注入其它的 Bean 实例外，还可以注入基本类型或者 String 类型的数据：

@Setter
public class UserDaoImpl implements UserDao {
    private String name;
    private int age;

    @Override
    public void save() {
        System.out.println("UserDaoImpl.save() is called.");
        System.out.printf("Name is %s and age is %d%n", name, age);
    }
}

Bean 定义：

<bean id="userDao"
      class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl">
    <property name="age" value="11"/>
    <property name="name" value="Tom"/>
</bean>

3.4.2.构造器注入

除了通过 Setter 进行注入，还可以通过构造器进行注入。

比如，用构造器注入其它 Bean：

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
	// ...
}

这里不再需要 Set 方法。

Bean 定义：

<bean id="userService"
      class="cn.icexmoon.springdemo.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

同样可以通过构造器注入简单类型：

public class UserDaoImpl implements UserDao {
    private String name;
    private int age;

    public UserDaoImpl(String name, int age) {
        this.name = name;
        this.age = age;
    }
	// ...
}

Bean 定义：

<bean id="userDao"
      class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl">
    <constructor-arg name="age" value="11"/>
    <constructor-arg name="name" value="tom"/>
</bean>

上面用构造器参数名称来“定位”参数进行注入的方式是最常见的，但这样意味着构造器的形参名称不能改变。

所以构造器注入存在一些变种写法，比如指定参数位置：

<bean id="userDao"
      class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl">
    <constructor-arg index="0" value="tom"/>
    <constructor-arg index="1" value="11"/>
</bean>

这样做的缺陷是构造器形参的位置不能改变。

还比如通过参数类型进行匹配：

<bean id="userDao"
      class="cn.icexmoon.springdemo.dao.impl.UserDaoImpl">
    <constructor-arg type="java.lang.String" value="tom"/>
    <constructor-arg type="int" value="11"/>
</bean>

这样做的缺陷是当形参中存在多个形参类型相同的情况，就无法完成匹配。

3.4.3.自动装配

使用自动装配可以省略手动注入的步骤：

<bean id="userService"
      class="cn.icexmoon.springdemo.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

将其改为自动装配：

<bean id="userService"
      class="cn.icexmoon.springdemo.service.impl.UserServiceImpl"
      autowire="byType">
</bean>

这样 Spring 就可以根据userService中依赖的类型来自动查找符合条件的 Bean 并进行注入。

现在运行会出现一个空指针异常，因为自动装配是通过 Setter 注入实现的，所以需要为相应的属性添加 Setter：

public class UserServiceImpl implements UserService {
    @Setter
    private UserDao userDao;
    // ...
}

除了按照类型自动装配，还可以按照名称自动装配：

<bean id="userService"
      class="cn.icexmoon.springdemo.service.impl.UserServiceImpl"
      autowire="byName">
</bean>

自动装配不能针对简单类型，只能针对其他的 Spring Bean，如果指定了 Setter 注入或构造器注入，自动装配会失效。

3.4.4.集合注入

如果属性依赖是集合，同样可以通过 Bean 定义完成注入：

@Setter
public class CollectionServiceImpl implements CollectionService {
    private Object[] array;
    private List<Object> list;
    private Set<Object> set;
    private Map<String, Object> map;
    private Properties properties;

    @Override
    public void print() {
        System.out.println("array:" + Arrays.toString(array));
        System.out.println("list:" + list);
        System.out.println("set:" + set);
        System.out.println("map:" + map);
        System.out.println("properties:" + properties);
    }
}

public interface CollectionService {
    void print();
}

public class Application {
    public static void main(String[] args) {
        // ...
        CollectionService collectionService = ctx.getBean(CollectionService.class);
        collectionService.print();
    }
}

Bean 定义：

<bean class="cn.icexmoon.springdemo.service.impl.CollectionServiceImpl">
    <property name="array">
        <array>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>Tom</value>
            <value>LiLei</value>
            <value>Jack</value>
        </list>
    </property>
    <property name="set">
        <set>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </set>
    </property>
    <property name="map">
        <map>
            <entry key="country" value="china"/>
            <entry key="province" value="sichuan"/>
            <entry key="city" value="chengdu"/>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="country">china</prop>
            <prop key="province">sichuan</prop>
            <prop key="city">chengdu</prop>
        </props>
    </property>
</bean>

除了注入字面量，也可以注入对其他 Bean 的引用。

比如说现在有多个 Person 类型的 Bean：

@Setter
@ToString
public class Person {
    private String name;
    private Integer age;
}

<bean id="tom" class="cn.icexmoon.springdemo.entity.Person">
    <property name="name" value="Tom"/>
    <property name="age" value="11"/>
</bean>
<bean id="liLei" class="cn.icexmoon.springdemo.entity.Person">
    <property name="name" value="LiLei"/>
    <property name="age" value="20"/>
</bean>
<bean id="jack" class="cn.icexmoon.springdemo.entity.Person">
    <property name="name" value="Jack"/>
    <property name="age" value="25"/>
</bean>

将其注入到 CollectionService 的一个集合属性中：

@Setter
public class CollectionServiceImpl implements CollectionService {
    // ...
    private List<Person> persons;

    @Override
    public void print() {
        // ...
        System.out.println("persons:" + persons);
    }
}

<bean class="cn.icexmoon.springdemo.service.impl.CollectionServiceImpl">
    <property name="persons">
        <list>
            <ref bean="jack"/>
            <ref bean="liLei"/>
            <ref bean="tom"/>
        </list>
    </property>
    <!-- ... -->
</bean>

5.案例：Spring 管理第三方数据源

步骤为先添加相应依赖，然后将数据源对象定义为 Bean，再通过依赖注入的方式传入数据库连接相关信息。

添加依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

Bean 定义：

<bean class="com.alibaba.druid.pool.DruidDataSource">
    <property name="username" value="root"/>
    <property name="password" value="mysql"/>
    <property name="url" value="jdbc://localhost:3306/test"/>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
</bean>

获取 Bean 实例：

DruidDataSource druidDataSource = ctx.getBean(DruidDataSource.class);
System.out.println(druidDataSource);
System.out.println("username:" + druidDataSource.getUsername());
System.out.println("password:"+druidDataSource.getPassword());
System.out.println("url:"+druidDataSource.getUrl());
System.out.println("driver:"+druidDataSource.getDriverClassName());

详细演示请观看这个视频。

6.从 properties 文件读取属性

上面的案例中，数据库连接信息直接被写在 Bean 定义文件中，这样做是不太好的，一般这些信息会使用单独的 properties 文件进行保存。

比如在 resource 目录下创建一个jdbc.properties：

jdbc.username=root
jdbc.password=mysql
jdbc.url=jdbc://localhost:3306/test
jdbc.driver=com.mysql.jdbc.Driver

在 Bean 定义中读取 properties 文件，需要先引入一个 XML 命名空间context：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- ... -->
</beans>

利用context:property-placeholder标签读取 properties 中的属性并导入占位符：

<context:property-placeholder location="jdbc.properties"/>

placeholder 是占位符的意思，即${}符号。

使用占位符进行注入：

<bean class="com.alibaba.druid.pool.DruidDataSource">
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="driverClassName" value="${jdbc.driver}"/>
</bean>

Spring 也会读取系统的环境变量，比如：

<property name="username" value="${username}"/>

虽然 properties 文件中没有定义，但实际上${username}的值是系统当前的用户名。

此时即使你在 properties 文件中定义了这个属性：

username=666

依然会是系统变量生效，也就是说系统环境变量优先级是高于 properties 中定义的属性的。

如果不希望在加载占位符属性时系统变量生效，可以：

<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>

如果需要加载多个 properties 文件：

<context:property-placeholder location="jdbc.properties,other.properties" system-properties-mode="NEVER"/>

可以使用,或空格进行分隔。

此外，还可以使用通配符加载多个文件：

<context:property-placeholder location="*.properties" system-properties-mode="NEVER"/>

默认情况下location中的文件名实际上都指的是从当前类路径（Class Path）中加载的文件，不过最好还是显式指定：

<context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"/>

但这样不会加载当前项目依赖的 jar 包中的配置文件，如果需要加载，可以：

<context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>

7.BeanFactory

BeanFactory 同样是一个表示 IoC 容器的接口，Spring 1.0 使用这个接口实现 IoC容器。

现在经常使用的ApplicatonContext接口扩展自BeanFactory：

image-20230821170738499

之前使用的ConfigurableApplicationContext接口扩展了Lifecycle接口，因此有close方法。

7.1.延迟加载 Bean

ApplicationContext 的实现类在加载 Bean 时默认为急切加载，比如：

public class CtxApplicaton {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
    }
}

如果要让某些 Bean 使用“延迟加载”，可以：

<bean id="userService"
      class="cn.icexmoon.springdemo.service.impl.UserServiceImpl"
      autowire="byName"
      lazy-init="true"/>

8.参考资料

魔芋红茶
关注
专栏目录
Spring Cloud 学习笔记（1 / 3）
KISS
03-03 21万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
Spring Cloud 学习笔记三：负载均衡
RHeng的博客
08-05 8105
负载均衡是指将网络请求或网络流量分散到多个服务器或网络节点上，以提高系统的整体处理能力和可用性。在微服务架构中，负载均衡器通常部署在客户端和服务提供者之间，负责将请求智能地分发到各个服务实例上，以确保没有单个服务实例过载，同时最大化资源利用率。Spring Cloud LoadBalancer允许开发者通过实现ReactorLoadBalancer接口来自定义负载均衡策略。开发者可以根据业务需求，编写复杂的负载均衡逻辑，以满足特定的需求。
Spring Cloud 学习笔记四：服务网关（Gateway）
RHeng的博客
08-05 5332
Spring Cloud Gateway 是基于 Spring Framework 5, Project Reactor 和 Spring WebFlux 的 API 网关，它为微服务架构提供了一种简单而有效的方式来路由和过滤请求。Spring Cloud Gateway 不仅具备传统网关的功能，如路由转发、负载均衡等，还通过提供丰富的路由匹配和过滤功能，使得开发者可以轻松地实现复杂的路由逻辑和请求处理流程。可以通过实现 GlobalFilter 或 GatewayFilter 接口来创建自定义过滤器。
SpringCloud学习笔记二：服务间调用
RHeng的博客
03-24 5257
微服务中，很多服务系统都在独立的进程中运行，通过各个服务系统之间的协作来实现一个大项目的所有业务功能。服务系统间 使用多种跨进程的方式进行通信协作，而RESTful风格的网络请求是最为常见的交互方式之一。在上一篇文章中我们介绍了服务的注册与发现，在此基础上我们将之前创建的eureka-client作为服务消费方创建一个服务提供方。
学习笔记：尚硅谷Spring6基础篇
D_boj的博客
08-14 3339
本章介绍，Spring6基础使用、Spring的IOC原理、Spring6整合日志框架、容器IOC、面向切面AOP以及依赖注入的方式、自动装配和依赖注入等
Spring6学习笔记7：国际化 i18n
最新发布
云扬的博客
09-15 951
本文是尚硅谷Spring6教程中国际化i18n的学习笔记。包括i18n概述、Java国际化、Spring6国际化等内容。供个人学习使用。
SpringCloud学习笔记一：服务注册与发现
RHeng的博客
03-21 1494
快速上手SpringCloud，学习笔记。
学习笔记：尚硅谷Spring6进阶篇
D_boj的博客
08-14 2532
本章介绍，单元测试Junit、事务、资源操作：Resource、国际化：i18n、数据校验：Validation、提前编译：AOT以及ResourceLoader和Resource的实现类的区别
Spring Boot 学习笔记 1 : 自定义 Banner
走马观花
01-15 1768
The banner that is printed on start up can be changed by adding a banner.txt file to your classpath or by setting the spring.banner.location property to the location of such a file...
Spring6学习笔记4：事务
云扬的博客
09-11 1588
本文是尚硅谷Spring6教程的第7章事务的学习笔记，包括JdbcTemplate的介绍与使用、事务的概念、基于注解的声明式事务、基于XML的声明式事务等内容。供个人学习使用。
spring-scheduling-sr:org.springframework.scheduling包源码阅读笔记，学习如何用好Java执行器（高级并发对象）-Spring Framework 3.2.10-源码包
03-24
在Spring Framework 3.2.10中，`org.springframework.scheduling`包是关于Spring调度功能的核心组件。这个包提供了全面的异步任务处理和定时任务管理能力，使得开发者能够轻松地实现定时任务和后台任务的执行。本文...
Spring Framework 学习笔记3：整合 MyBatis+JUnit
梦幻天空
09-29 199
本文介绍如何在 Spring 框架中整合 MyBatis 和 Junit。
【spring】学习笔记1：starter和application
突围
08-30 494
WafApplication
从零开始 Spring Boot 18：微信登录
梦幻天空
08-15 5288
在之前的文章中我介绍了如何给Spring Boot开发的Web应用添加Shiro身份验证模块，这样我们就可以通过用户/密码的方式让用户进行登录。当然了，这种方式就必须要求用户先进行注册，或者管理员为用户预先添加帐号才行，所以如果我们需要降低用户使用系统干的门槛，让用户更容易登录系统，就可以接入第三方登录。而天朝最流行的第三方登录就是微信，这点应该是没有争议的。下面就介绍如何在现有用户/密码登录体系外额外接入微信登录。...
从零开始 Spring Boot 16：枚举
梦幻天空
08-05 2708
在开发Web应用时，无法避免的是会定义一些“离散值”，比如书籍类型，包含艺术、小说、工程书籍等。在数据库中，我们一般会使用整数来表示这些值，比如1代表小说，2代表艺术，3代表工程相关书籍等。但在代码中使用整数来表示类型可读性就很差了，以前一般使用类常量来表示这些值，但更好的做法是使用枚举。关于Java中枚举的基本知识，可以阅读。下面通过在我们的图书应用中引入枚举类型来说明如何在Spring Boot项目中使用枚举，以及相关的注意事项。下面的示例代码都将由中的最终代码修改而来，相关完整代码见。表的。...
从零开始 Spring Boot 51：JPA 中的默认列值
梦幻天空
06-29 2477
JPA 是一个 ORM 框架，因此，通常我们需要在实体类中定义表结构，这其中就包含可能的字段默认值。本文介绍如何在 Hibernate（JPA）中设置默认列值（Default Column Value）。
IDEA生成spring boot项目jar包
梦幻天空
04-26 2023
IDEA生成spring boot项目jar包 刚上手IDEA做sping boot项目，学习过程中遇到一些坑，具体我也不清楚为什么IDEA的默认项生成jar包会产生这些问题，但经过以下折腾后的确可以解决问题，所以先记录。 用IDEA打开一个spring boot项目： File>project structure： project settings > Artifacts选项卡中点加号： 依次选择JAR > From modules… 然后是重点： 这里必须像上图这样设置：
从零开始 Spring Boot 37：初始化 ApplicationContext
梦幻天空
06-12 1700
从前文可以知道，作为 Ioc 容器的 ApplicationContext，需要进行一系列步骤来初始化以最终就绪（对于 Web 应用来说就是可以提供Http服务）。
Spring Framework 5入门指南：核心概念与优势解析
"Spring Framework 5的学习笔记，包括其历史、理念、优点以及核心组件的介绍。" Spring Framework是Java开发中的一个关键框架，由Rod Johnson于2002年创立，最初命名为interface21，2004年发布1.0正式版。Spring的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值