[秃头之路]Spring详解_(中)

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量170 收藏
点赞数
分类专栏： 学习 Java 框架 文章标签： java
Java 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
学习
9 篇文章 0 订阅
订阅专栏
框架
2 篇文章 0 订阅
订阅专栏

Spring详解

三. DI依赖注入

  上一篇博客我们主要讲解了IOC控制反转，也就是说IOC 让程序员不在关注怎么去创建对象，而是关注与对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做。那么创建对象的时候，有可能依赖于其他的对象，即类的属性如何赋值？这也是我们这篇博客讲解 Spring 另一个核心要点：DI依赖注入。

  3.1、什么是DI依赖注入？

  Spring动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

  简单来说什么是依赖注入，就是给属性赋值（包括基本数据类型和引用数据类型）

  3.2、利用 set 方法给属性赋值

第一步：创建工程，并导入相应的 jar 包

第二步：创建实体类 Person

package com.ys.di;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
 
public class Person {
    private Long pid;
    private String pname;
    private Student students;
    private List lists;
    private Set sets;
    private Map maps;
    private Properties properties;
    //get set 略
}

我们看到这个实体类包括引用类型 Student 类，基本数据类以及集合数据类型。

第三步：在 applicationContext.xml 中进行赋值

<!--
    property是用来描述一个类的属性
    基本类型的封装类、String等需要值的类型用value赋值
    引用类型用ref赋值
-->
<bean id="person" class="com.ys.di.Person">
    <property name="pid" value="1"></property>
    <property name="pname" value="vae"></property>
    <property name="students">
        <ref bean="student"/>
    </property>
     
    <property name="lists">
        <list>
            <value>1</value>
            <ref bean="student"/>
            <value>vae</value>
        </list>
    </property>
     
    <property name="sets">
        <set>
            <value>1</value>
            <ref bean="student"/>
            <value>vae</value>
        </set>
    </property>
     
    <property name="maps">
        <map>
            <entry key="m1" value="1"></entry>
            <entry key="m2" >
                <ref bean="student"/>
            </entry>
        </map>
    </property>   
     
    <property name="properties">
        <props>
            <prop key="p1">p1</prop>
            <prop key="p2">p2</prop>
        </props>
    </property>  
     
</bean>
 
 
<bean id="student" class="com.ys.di.Student"></bean>

第四步：测试

//利用 set 方法给对象赋值
    @Test
    public void testSet(){
        //1、启动 spring 容器
        //2、从 spring 容器中取出数据
        //3、通过对象调用方法
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person.getPname());//vae
    }

  3.3、利用 构造函数 给属性赋值

第一步：在实体类 Per’son.java 中添加两个构造方法：有参和无参

//默认构造函数
    public Person(){}
    //带参构造函数
    public Person(Long pid,Student students){
        this.pid = pid;
        this.students = students;
    }

第二步：在 applicationContext.xml 中进行赋值

<!-- 根据构造函数赋值 -->
    <!--
        index  代表参数的位置  从0开始计算
        type   指的是参数的类型,在有多个构造函数时，可以用type来区分，要是能确定是那个构造函数，可以不用写type
        value  给基本类型赋值
        ref    给引用类型赋值
      -->
    <bean id="person_con" class="com.ys.di.Person">
        <constructor-arg index="0" type="java.lang.Long" value="1">
        </constructor-arg>       
        <constructor-arg index="1" type="com.ys.di.Student" ref="student_con"></constructor-arg>
    </bean>
    <bean id="student_con" class="com.ys.di.Student"></bean>

第三步：测试

//利用 构造函数 给对象赋值
    @Test
    public void testConstrutor(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person_con");
        System.out.println(person.getPid());//1
    }

总结：

1、如果spring的配置文件中的bean中没有该元素，则调用默认的构造函数

2、如果spring的配置文件中的bean中有该元素，则该元素确定唯一的构造函数

四. 注解配置IOC、DI

  Annotation(注解)是JDK1.5及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注解是以‘@注解名’在代码中存在的。

  前面讲解 IOC 和 DI 都是通过 xml 文件来进行配置的，我们发现 xml 配置还是比较麻烦的，那么如何简化配置呢？答案就是使用注解！

  4.1、注解 @Component

我们这里有个类 Person

package com.ys.annotation;
 
public class Person {
    private int pid;
    private String pname;
    private String psex;
    
    //get set 略
}

如果我们不使用注解，通过前面讲解的，要想让 Spring 容器帮我们产生 Person 对象，我们要进行如下配置：

applicationContext.xml 配置：

<bean id="person" class="com.ys.annotation.Person"></bean>

如果使用注解呢？

第一步：在 applicationContext.xml 中引入命名空间
在这里插入图片描述
　　这里我们简单讲解一下这里引入的命名空间，简单来说就是用来约束xml文件格式的。第一个 xmlns:context ，这表示标签格式应该是 <\context:标签名>
　　
第二步:在 applicationContext.xml 文件中引入注解扫描器

<!-- 组件扫描，扫描含有注解的类 -->
    <context:component-scan base-package="com.ys.annotation"></context:component-scan>

base-package：表示含有注解类的包名

如果扫描多个包，则上面的代码书写多行，改变 base-package 里面的内容即可！

第三步：在 Person 类中添加注解@Component
在这里插入图片描述

第四步：测试

	@Test
    public void testAnnotation(){
        //1、启动 spring 容器
        //2、从 spring 容器中取出数据
        //3、通过对象调用方法
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person.getPname());
    }

如果看完上面的注解配置，你一脸懵逼，那没关系，我们下面来详细讲解。

@Component

如果一个类上加了@Component注解，就会进行如下的法则

    　　　　　　如果其value属性的值为""

         　　　　　　 @Component

         　　　　　　 public class Person {}

          　　　　　　　　等价于

          　　　　　　<bean id="person" class="..Person">

  　　　　　　 如果其value属性的值不为""

         　　　　　　 @Component("p")

          　　　　　　public class Person {}

         　　　　　　　　等价于

         　　　　　　<bean id="p" class="..Person">

那么这就很好理解测试程序中，我们直接 context.getBean(“person”) 这样写。

  4.2、@Repository @Service @Controller

此外：下面三个注解是 @Component 注解的衍生注解，功能一样

@Repository ：dao层
@Service：service层
@Controller：web层

  4.3、注解 @Resource

@Resource 注解，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。 通过 @Resource 的使用来消除 set ，get方法。

首先创建一个 学生类 Student.java
在这里插入图片描述
　然后在 Person 类中添加一个属性 Student
　在这里插入图片描述
　那么我们如何获取 Person 对象，并调用 showStudent()方法呢？这个问题简化就是如何给属性 Student 实例化，也就是依赖注入

不使用注解：

<property name="students">
    <ref bean="student"/>
</property>
<bean id="student" class="com.ys.annotation_di.Student"></bean>

使用注解：
　在这里插入图片描述
@Resource注解以后，判断该注解name的属性是否为""(name没有写)

  ①、如果没有写name属性，则会让属性的名称的值和spring配置文件bean中ID的值做匹配（如果没有进行配置，也和注解@Component进行匹配），如果匹配成功则赋值，如果匹配不成功，则会按照spring配置文件class类型进行匹配，如果匹配不成功，则报错

  ②、如果有name属性，则会按照name属性的值和spring的bean中ID进行匹配，匹配成功，则赋值，不成功则报错

  4.4、注解 @Autowired

功能和注解 @Resource 一样，可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。只不过注解@Resource 是按照名称来进行装配，而@Autowired 则是按照类型来进行装配。

第一步：创建接口 PersonDao

package com.ys.autowired;
 
public interface PersonDao {
     
    public void savePerson();
 
}

第二步：创建一个接口实现类 PersonDaoImplOne

package com.ys.autowired;
 
import org.springframework.stereotype.Component;
 
@Component("personDaoImplOne")
public class PersonDaoImplOne implements PersonDao{
 
    @Override
    public void savePerson() {
        System.out.println("save Person One");
         
    }
}

第三步：创建PersonService

package com.ys.autowired;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service("personService")
public class PersonService{
    @Autowired
    private PersonDao personDao;
     
    public void savePerson() {
        this.personDao.savePerson();
    }
 
}

注意：这里我们在 private PesronDao personDao 上面添加了注解 @Autowired，它首先会根据类型去匹配，PersonDao 是一个接口，它的实现类是 PesronDaoImpOne，那么这里的意思就是：

PersonDao personDao = new PersonDaoImpOne();

那么问题来了，如果 PersonDao 的实现类有多个呢？我们创建第一个实现类

package com.ys.autowired;
 
import org.springframework.stereotype.Component;
 
@Component("personDaoImplTwo")
public class PersonDaoImplTwo implements PersonDao{
 
    @Override
    public void savePerson() {
        System.out.println("save Person Two");
         
    }
 
}

如果还是向上面那样写，那么测试就会报错。怎么解决呢？

第一种方法：更改名称
在这里插入图片描述
　第二种方法：@Autowired 和 @Qualifier(“名称”) 配合使用
　在这里插入图片描述
在使用@Autowired时，首先在容器中查询对应类型的bean

  如果查询结果刚好为一个，就将该bean装配给@Autowired指定的数据

  如果查询的结果不止一个，那么@Autowired会根据名称来查找。

  如果查询的结果为空，那么会抛出异常。解决方法时，使用required=false

五. AOP (重点)

Spring 的核心概念—AOP，这也是 Spring 框架中最为核心的一个概念。

  5.1、AOP 什么？

  AOP（Aspect Oriented Programming），通常称为面向切面编程。它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

  什么是切面，什么是公共模块，那么我们概念少说，直接通过一个实例来看看 AOP 到底是什么。

  5.2、需求

现在有一张表 User,然后我们要在程序中实现对 User 表的增加和删除操作。

要求：增加和删除操作都必须要开启事务，操作完成之后要提交事务。

User.java

package com.ys.aop.one;
 
public class User {
    private int uid;
    private String uname;

	//getset 略
}

  5.3、解决办法1:使用静态代理

第一步：创建 UserService 接口

package com.ys.aop.one;
 
public interface UserService {
    //添加 user
    public void addUser(User user);
    //删除 user
    public void deleteUser(int uid);
}

第二步:创建 UserService的实现类

package com.ys.aop.one;
 
public class UserServiceImpl implements UserService{
    @Override
    public void addUser(User user) {
        System.out.println("增加 User");
    }
    @Override
    public void deleteUser(int uid) {
        System.out.println("删除 User");
    }
}

第三步：创建事务类 MyTransaction

package com.ys.aop.one;
 
public class MyTransaction {
    //开启事务
    public void before(){
        System.out.println("开启事务");
    }
    //提交事务
    public void after(){
        System.out.println("提交事务");
    }
}

第四步：创建代理类 ProxyUser.java

package com.ys.aop.one;
 
public class ProxyUser implements UserService{
    //真实类
    private UserService userService;
    //事务类
    private MyTransaction transaction;
    //使用构造函数实例化
    public ProxyUser(UserService userService,MyTransaction transaction){
        this.userService = userService;
        this.transaction = transaction;
    }
    @Override
    public void addUser(User user) {
        transaction.before();
        userService.addUser(user);
        transaction.after();
    }
    @Override
    public void deleteUser(int uid) {
        transaction.before();
        userService.deleteUser(uid);
        transaction.after();       
    }
}

测试：

	@Test
    public void testOne(){
        MyTransaction transaction = new MyTransaction();
        UserService userService = new UserServiceImpl();
        //产生静态代理对象
        ProxyUser proxy = new ProxyUser(userService, transaction);
        proxy.addUser(null);
        proxy.deleteUser(0);
    }

结果：
在这里插入图片描述
  这是一个很基础的静态代理，业务类UserServiceImpl 只需要关注业务逻辑本身，保证了业务的重用性，这也是代理类的优点，没什么好说的。我们主要说说这样写的缺点：

  ①、代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

  ②、如果接口增加一个方法，比如 UserService 增加修改 updateUser(）方法，则除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

  5.4、解决办法2：使用JDK动态代理

动态代理就不要自己手动生成代理类了，我们去掉 ProxyUser.java 类，增加一个 ObjectInterceptor.java 类

package com.ys.aop.two;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
import com.ys.aop.one.MyTransaction;
 
public class ObjectInterceptor implements InvocationHandler{
    //目标类
    private Object target;
    //切面类（这里指事务类）
    private MyTransaction transaction;
     
    //通过构造器赋值
    public ObjectInterceptor(Object target,MyTransaction transaction){
        this.target = target;
        this.transaction = transaction;
    }
     
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //开启事务
        this.transaction.before();
        //调用目标类方法
        method.invoke(this.target, args);
        //提交事务
        this.transaction.after();
        return null;
    } 
}

测试：

	@Test
    public void testOne(){
        //目标类
        Object target = new UserServiceImpl();
        //事务类
        MyTransaction transaction = new MyTransaction();
        ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction);
        /**
         * 三个参数的含义：
         * 1、目标类的类加载器
         * 2、目标类所有实现的接口
         * 3、拦截器
         */
        UserService userService = (UserService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), proxyObject);
        userService.addUser(null);
    }

结果：
在这里插入图片描述
  那么使用动态代理来完成这个需求就很好了，后期在 UserService 中增加业务方法，都不用更改代码就能自动给我们生成代理对象。而且将 UserService 换成别的类也是可以的。

  也就是做到了代理对象能够代理多个目标类，多个目标方法。

  注意：我们这里使用的是 JDK 动态代理，要求是必须要实现接口。与之对应的另外一种动态代理实现模式 Cglib，则不需要，我们这里就不讲解 cglib 的实现方式了。

  不管是哪种方式实现动态代理。本章的主角：AOP 实现原理也是动态代理

  5.5、AOP 关键术语

    1.target：目标类，需要被代理的类。例如：UserService
    2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
    3.PointCut 切入点：已经被增强的连接点。例如：addUser()
    4.advice 通知/增强，增强代码。例如：after、before
    5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
    6.proxy 代理类：通知+切入点
    7. Aspect(切面): 是切入点pointcut和通知advice的结合

具体可以根据下面这张图来理解：
在这里插入图片描述

  5.6、AOP 的通知类型

      Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

      前置通知 org.springframework.aop.MethodBeforeAdvice

            * 在目标方法执行前实施增强，比如上面例子的 before()方法

      后置通知 org.springframework.aop.AfterReturningAdvice

            *在目标方法执行后实施增强，比如上面例子的 after()方法

      环绕通知 org.aopalliance.intercept.MethodInterceptor

            *在目标方法执行前后实施增强

      异常抛出通知 org.springframework.aop.ThrowsAdvice

            *在方法抛出异常后实施增强

      引介通知 org.springframework.aop.IntroductionInterceptor

            *在目标类中添加一些新的方法和属性

  5.7、使用 Spring AOP 解决上面的需求

我们只需要在Spring 的配置文件 applicationContext.xml 进行如下配置：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--1、 创建目标类 -->
    <bean id="userService" class="com.ys.aop.UserServiceImpl"></bean>  
    <!--2、创建切面类（通知）  -->
    <bean id="transaction" class="com.ys.aop.one.MyTransaction"></bean>
     
    <!--3、aop编程 
        3.1 导入命名空间
        3.2 使用 <aop:config>进行配置
                proxy-target-class="true" 声明时使用cglib代理
                如果不声明，Spring 会自动选择cglib代理还是JDK动态代理
            <aop:pointcut> 切入点 ，从目标对象获得具体方法
            <aop:advisor> 特殊的切面，只有一个通知 和 一个切入点
                advice-ref 通知引用
                pointcut-ref 切入点引用
        3.3 切入点表达式
            execution(* com.ys.aop.*.*(..))
            选择方法         返回值任意   包             类名任意   方法名任意   参数任意
     
    -->
    <aop:config>
        <!-- 切入点表达式 -->
        <aop:pointcut expression="execution(* com.ys.aop.*.*(..))" id="myPointCut"/>
        <aop:aspect ref="transaction">
            <!-- 配置前置通知，注意 method 的值要和 对应切面的类方法名称相同 -->
            <aop:before method="before" pointcut-ref="myPointCut"></aop:before>
            <aop:after-returning method="after" pointcut-ref="myPointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

测试：

	@Test
    public void testAop(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService useService = (UserService) context.getBean("userService");
        useService.addUser(null);
    }

结果：
在这里插入图片描述

上面的配置我们在注释中写的很清楚了。这里我们重点讲解一下：
　　①、 切入点表达式，一个完整的方法表示如下：

execution（modifiers-pattern? ref-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?）

那么根据上面的对比，我们就很好理解：

execution(* com.ys.aop.*.*(..))
选择方法         返回值任意   包             类名任意   方法名任意   参数任意

②、springAOP 的具体加载步骤：

  1、当 spring 容器启动的时候，加载了 spring 的配置文件

  2、为配置文件中的所有 bean 创建对象

  3、spring 容器会解析 aop:config 的配置

     解析切入点表达式，用切入点表达式和纳入 spring 容器中的 bean 做匹配

     如果匹配成功，则会为该 bean 创建代理对象，代理对象的方法=目标方法+通知

     如果匹配不成功，不会创建代理对象

  4、在客户端利用 context.getBean() 获取对象时，如果该对象有代理对象，则返回代理对象；如果没有，则返回目标对象

  说明：如果目标类没有实现接口，则 spring 容器会采用 cglib 的方式产生代理对象，如果实现了接口，则会采用 jdk 的方式

----------------转自作者: YSOcean 出处: http://www.cnblogs.com/ysocean/

Gaby.kang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Cloud Alibaba Nacos 详解
05-05
Spring Cloud Alibaba Nacos 是阿里巴巴开源的一款分布式服务治理和配置中心的组件，它提供了服务发现、配置管理、命名服务等关键功能，旨在简化微服务架构中的服务管理和配置问题。Nacos 作为 Spring Cloud 生态...
JDK_API 中文帮助文档
12-26
API文档详细列出了这些版本中的所有编程元素，使得开发者能够了解如何利用这些新特性进行开发。 文档的主体部分通常按照包（package）的层次结构组织，每个包下包含若干类和接口。例如，`java.lang`包是最基础的包...
[秃头之路]Spring详解_(上)
丹康丶的博客
07-09 283
Spring详解一. 概述1.1、什么是 spring ?1.2、Spring 起源1.3、 Spring特点1.4、Spring 框架结构1.5、Spring 框架特征1.6、 Spring 优点二. IOC控制反转2.1、 什么是IOC?　IOC-Inversion of Control，即控制反转。它不是什么技术，而是一种设计思想。2.2、 分享Bromon的blog上对IOC与DI浅显易懂...
Spring Data JPA 之 @Query 语法详解及其应用
热门推荐
曾小二的博客
05-29 1万+
5 Spring Data JPA 之 @Query 语法详解及其应用 5.1 快速体验 @Query 的方法 沿⽤我们之前的例⼦，新增⼀个 @Query 的⽅法： // 通过 query 注解根据 name 查询 user 信息 @Query("From User where name=:name") User findByQuery(@Param("name") String nameParam); 新增⼀个测试方法： @Test public void testQueryAnnotation() {
Spring-Bean配置文件详解
z123ljx的博客
03-19 1905
目录 前言： 一：Bean-Scope配置属性 二.生命周期配置 三.实例化三种方式 前言： 在之前学习了spring的基础使用，在其中涉及到了xml的配置文件的配置，其中有个Bean的配置，而本章就是分析Bean的配置的一些属性的 一：Bean-Scope配置属性 Scope是指定对象的作用范围的，也就是指定spring能够创建几个容器 Scope-singleton 这个Scope的默认值，它表示的是单列模式也就是说只能创建一个容器 <bean id="UserDao"
Spring data JPA 之 Jackson 在实体里面的注解详解
曾小二的博客
06-18 1353
实际⼯作中实体⾥⾯不仅有 JPA 的注解，也会⽤到很多 JSON 相关的注解。我们⽤ Spring Boot ⾥⾯默认集成的 fasterxml.jackson 加以说明，这看似和 JPA 没什么关系，但是⼀旦我们和 @Entity ⼀起使⽤的时候，就会遇到⼀些问题，特别是新⼿同学，我们这⼀课时详细介绍⼀下⽤法。先来跟着我了解⼀下 Jackson 的基本语法。当我们⽤ spring boot starter 的时候就会默认加...
Spring Data JPA 之 DataSource 详解及其加载过程
曾小二的博客
08-14 1481
如果我们修改默认策略，只需要在 application.properties ⾥⾯修改下⾯代码所示的两个配置，换成⾃⼰的⾃定义的类即可。如果我们直接搜索：spring.jpa.hibernate 就会发现，其默认配置是在这类⾥⾯的其中，IMPLICIT_NAMING_STRATEGY 和 PHYSICAL_NAMING_STRATEGY 的值如下述代码所示，它是 Hibernate 5 的配置变量，⽤来改变 Hibernate的 naming 的策略。...
SpringCloud学习：RestTemplate详解
曾小二的博客
07-11 420
RestTemplate详解 一，Get请求 在RestTemplate中通过如下两个方法进行调用 第一种：getForEntity()函数 返回：ResponseEntity（对HTTP响应的封装，重要元素：HTTP请求状态的枚举对象HttpStatus，HTTP请求头信息对象HttpHeaders,泛型的请求体对象） 例如： RestTemplate restTemplate = new R...
Spring Data JPA 之 @Entity 的常用注解
曾小二的博客
05-31 6474
6 Spring Data JPA 之 @Entity 的常用注解 前⼏课时介绍了 Repository 的⽤法，其中经常会提到“实体类”（即前⾯的User 类），它是对我们数据库中表的 Metadata 映射，那么具体如何映射呢？这⼀课时我们来讲解。 我们先看⼀下 Java Persistence API ⾥⾯都有哪些重要规定；再通过讲解基本注解，重点介绍⼀下联合主键和实体之间的继承关系，然后你就会知道 JPA 的实体⾥⾯常⻅的注解有哪些。先来看⼀下 Entity 的相关规定。 6.1 JPA 协议中关于
秃头大牛一文竟然就把SpringCloudStream（SCS）给讲明白了？
公众号：该用户快成仙了
10-07 466
Spring Cloud对Spring Cloud Stream（简称SCS）的定位是用于构建高度可扩展的基于事件驱动的微服务，其目的是简化消息在Spring Cloud应用程序中的开发。同时SCS能够提供一套灵活可扩展的编程模型，在Spring的基础上，支持发布/订阅模型、消费者分组、数据分片等。使用SCS能使微服务基于消息驱动的开发模式更加简单透明。SCS的架构SCS可以简单地理解为是对第三方消息中间件的一个概念封装，开发人员可以将关注点从消息中间件的特性配置转移到对消息的配置。
MATLAB从入门到秃头-各章案例源文件_MATLAB从入门到秃头-各章案例源文件_matlab_
10-01
《MATLAB从入门到秃头-各章案例源文件》是一个综合性的学习资源包，旨在帮助初学者逐步掌握MATLAB编程技术，同时也适用于有一定基础的用户深入理解和实践MATLAB的各种功能。MATLAB（Matrix Laboratory）是一款强大的...
daydayup:成长之路？no！秃头之旅？yes！
05-13
【标题】"daydayup:成长之路？no！秃头之旅？yes！" 暗示了这是一个关于程序员日常学习和成长的项目，其中可能包含了作者在编程技能提升过程中的学习资源、笔记或者代码实践。从描述来看，"个人知识仓库(持续更新ing...
Spring Security 笔记思维导图
03-01
Spring Boot 整合 Spring Security 包含认证,授权,加密,验证码,前后端分离,记住密码,自定义组件等
枚举工具类
qq_43049583的博客
08-04 227
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 292
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
深入理解Java注解
weixin_55745942的博客
08-01 641
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 624
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 571
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
nginx配置文件中的include用法详解
06-06
在nginx的配置文件中，可以使用include指令来引入其他的配置文件，该指令的语法如下： ``` include file | mask; ``` 其中，file参数表示要引入的配置文件的路径，mask参数则表示要引入的一组配置文件路径的通配符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值