Spring 学习笔记

最新推荐文章于 2024-07-08 18:16:19 发布
最新推荐文章于 2024-07-08 18:16:19 发布
阅读量64 收藏
点赞数
分类专栏： Spring 学习 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yeyuangongzuoshi/article/details/114836012
版权

Spring学习

Spring是一个轻量级控制反转IOC和面向切面编程AOP的框架

Spring Boot 快速开发的脚手架

Spring Cloud 基于Springboot实现

学习SpringBoot的前提掌握Spring 以及SpringMVC

Spring中文文档：Spring Framework 5.1.3.RELEASE 中文文档 | Docs4dev

IOC基本实现（DI注入）：

代码忘保存了 略

HELLO SPRING：

pojo：

package com.su.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

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="Hello" class="com.su.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>


</beans>

Test:

import com.su.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Hello hello = (Hello) context.getBean("Hello");
        System.out.println(hello.toString());

    }
}

image-20210309133541050

@AutoWired(本质是byType):

image-20210309162252051

package com.su.pojo;

public class Cat {
    public void shout(){
        System.out.println("miao");
    }
}

package com.su.pojo;

public class Dog {
        private String name;

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void shout(){
            System.out.println(name+"wang");
        }


}


package com.su.pojo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class People {
//还可以用@Resource(name="")注解
    private String name;
    @Autowired
    private Cat cat;
    @Autowired
    @Qualifier(value="Dog1")
    private Dog dog;

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", cat=" + cat +
                ", dog=" + dog +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }
}

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.xsd">

    <context:annotation-config/>
    <bean id="People" class="com.su.pojo.People"/>
    <bean id="Cat" class="com.su.pojo.Cat"/>
    <bean id="Dog" class="com.su.pojo.Dog">
        <property name="name" value="dog"/>
    </bean>
    <bean id="Dog1" class="com.su.pojo.Dog">
        <property name="name" value="dog1"/>
    </bean>

</beans>

image-20210309163045834

自动扫描包：

@Component 一个意思的注解：

@Repository（Dao）

@Service（service）

@Controller（Controller）

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.xsd">
    <context:component-scan base-package="com.su"/>
    <context:annotation-config/>


</beans>

AOP：

实现前线maven加载：

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

老老实实的：

log：

package com.su.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AopAfter implements AfterReturningAdvice {
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("之后打印");
    }
}

package com.su.log;

import org.springframework.aop.BeforeAdvice;
import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class AopBefore implements MethodBeforeAdvice {

    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("之前打印");
    }
}

接口：

package com.su.service;

public interface UserSerivce {
    public void add();
    public void delete();
}

实现类：

package com.su.service;

public class UserServiceimp implements UserSerivce {
    public void add() {
        System.out.println("添加完成");
    }

    public void delete() {
        System.out.println("删除完成");
    }
}

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: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
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.su.service.UserServiceimp"/>
    <bean id="logbf" class="com.su.log.AopBefore"/>
    <bean id = "logaf" class="com.su.log.AopAfter"/>
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.su.service.UserServiceimp.*(..))"/>

        <aop:advisor advice-ref="logbf" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="logaf" pointcut-ref="pointcut"/>
     </aop:config>


</beans>

测试类：

import com.su.service.UserSerivce;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("Bean.xml");
        UserSerivce userservice = (UserSerivce) applicationContext.getBean("userService");
        userservice.add();
        userservice.delete();
    }

}

image-20210311181355486

自定义类：

log类：

package com.su.log;

public class DiyAop {
    public void Before(){
        System.out.println("============之前");
    }
    public void After(){
        System.out.println("============之后");
    }

}

xml配置：

<aop:aspect ref="logDiy">
    <aop:pointcut id="pointcut" expression="execution(* com.su.service.UserServiceimp.*(..))"/>
    <aop:before method="Before" pointcut-ref="pointcut"/>
    <aop:after method="After" pointcut-ref="pointcut"/>
</aop:aspect>

image-20210311182857578

用注解实现：

xml：

<bean id = "Diyaopzhujie" class="com.su.log.DiyAopzhujie"/>
<aop:aspectj-autoproxy/>

class：

package com.su.log;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class DiyAopzhujie {
    @Before("execution(* com.su.service.UserServiceimp.*(..))")
    public void Before(){
        System.out.println("============之前");
    }
    @After("execution(* com.su.service.UserServiceimp.*(..))")
    public void After(){
        System.out.println("============之后");
    }
}

整合mybatis：

导包：

注意spring和mybatis的版本号

image-20210312170459840

<?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">
    <parent>
        <artifactId>Spring-study</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>Spring-06-Mybatis</artifactId>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.18</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

mapper：

package com.su.mapper;

import com.su.pojo.User;

import java.util.List;

public interface UserMapper {
     List<User> getUserList();
}

<?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">
<mapper namespace="com.su.mapper.UserMapper">
    <select id="getUserList" resultType="com.su.pojo.User" >
        select * from demo.user
    </select>


</mapper>

package com.su.mapper;

import com.su.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImp implements UserMapper {
    private SqlSessionTemplate sqlSessionTemplate;

    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    public List<User> getUserList() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();

        return userList;
    }
}

实体类：

package com.su.pojo;

import lombok.Data;

public class User {
    private int userid;
    private String username;
    private String userpassword;
    private String userpic;
    private String userpower;
    private String useraddress;

    public User() {
    }

    public User(int userid, String username, String userpassword, String userpic, String userpower, String useraddress) {
        this.userid = userid;
        this.username = username;
        this.userpassword = userpassword;
        this.userpic = userpic;
        this.userpower = userpower;
        this.useraddress = useraddress;
    }

    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUserpassword() {
        return userpassword;
    }

    public void setUserpassword(String userpassword) {
        this.userpassword = userpassword;
    }

    public String getUserpic() {
        return userpic;
    }

    public void setUserpic(String userpic) {
        this.userpic = userpic;
    }

    public String getUserpower() {
        return userpower;
    }

    public void setUserpower(String userpower) {
        this.userpower = userpower;
    }

    public String getUseraddress() {
        return useraddress;
    }

    public void setUseraddress(String useraddress) {
        this.useraddress = useraddress;
    }

    @Override
    public String toString() {
        return "User{" +
                "userid=" + userid +
                ", username='" + username + '\'' +
                ", userpassword='" + userpassword + '\'' +
                ", userpic='" + userpic + '\'' +
                ", userpower='" + userpower + '\'' +
                ", useraddress='" + useraddress + '\'' +
                '}';
    }
}

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: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
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    datasource-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/demo?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <!--    sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/su/mapper/UserMapper.xml"/>
    </bean>

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </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.su.pojo"/>
  </typeAliases>

</configuration>

<?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: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
        https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--    datasource-->

    <import resource="applicationContext.xml"/>

    <bean id="userMapper" class="com.su.mapper.UserMapperImp">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>
</beans>

test：

import com.su.mapper.UserMapper;
import com.su.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    @Test
    public void testv(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("springDao.xml");
        UserMapper userMapper = applicationContext.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.getUserList()) {
            System.out.println(user);
        }

    }


}

甚至可以去掉注入：

更快捷的方法:

    <import resource="applicationContext.xml"/>

    <bean id="userMapper" class="com.su.mapper.UserMapperImp">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>
    <bean id ="UserMapper2" class="com.su.mapper.UserMapper2Impl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
</beans>

package com.su.mapper;

import com.su.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapper2Impl extends SqlSessionDaoSupport implements UserMapper {
    public List<User> getUserList() {
        return getSqlSession().getMapper(UserMapper.class).getUserList();
    }
}

aop事务管理：

最好不要加中文注释 天天报错

建议删除中文注释

<!--    aop事务管理-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>


<!--    结合Aop食物的织入-->
<!--    配置事物的传播特性  propagation传播-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
<!-- 配置事物   -->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.su.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
yeyuangongzuoshi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javaSpring学习笔记
03-12
“Java Spring学习笔记”是一份宝贵的资源，专门为想要学习和掌握Java Spring框架的开发者而设计。这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用...
spring 学习笔记
05-08
下面将根据“spring 学习笔记”的主题，对Spring框架进行深入的探讨。 一、依赖注入（DI） 依赖注入是Spring的核心功能，它允许对象之间的依赖关系在运行时动态地管理和配置，而不是在代码中硬编码。这样可以提高...
Spring学习笔记 自我总结
11-02
spring学习笔记
spring学习笔记
02-07
本笔记是spring4的，所有内容亲测，方便初学者学习之用。
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
springboot基于Java的超市进销存系统+ LW+ PPT+源码+讲解
u014445459的博客
07-06 667
操作的多样性也变高了。由此可见，本系统在操作上是可行的。软件测试的方法有好几种，但目前主要采用的是包括以功能为主要测试方向的黑盒测试以及以逻辑为主要测试方向的白盒测试，这是两种不同的测试方法，针对的测试侧重点不同，本课题根据实际需求情况，选择以功能为主要的黑盒测试方法，同时测试是要遵循一定的规则来执行的，一个测试要执行其执行的依据一般是由测试用例来规定的，而测试用例一般是依据需求或说明书来综合制定的，测试在硬件出厂前是十分重要的一个过程，本课题由于时间和精力的关系，选择以实现的功能作为测试要点来进行测试。
SpringBoot AOP切入点表达式
生产队的驴
07-05 243
在AOP中可以通过@Around注解来定义 切入点表达式来控制被监控的方法。匹配 com.example.service 包中的任何类的 save 方法，且方法参数为 java.lang.String 类型。
springboot项目多模块工程==1搭建
溪
07-06 275
idea springboot 项目多模块工程搭建配置
学习springMVC
weixin_45621552的博客
07-03 521
JSR全称为 Java Specification Requests，表示 Java 规范提案。JSR-303是 Java 为 Java Bean 数据合法性校验提供的标准框架，它定义了一套可标注在成员变量，属性方法上的校验注解。Hibernate Validatior提供了这套标准的实现。-- 最新7.0.1.Final --> </ dependency >-- 最新7.0.1.Final --> </ dependency ></
【SpringBoot3】结合 gRpc 实现远程服务调用
最新发布
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
07-08 698
gRPC（Google Remote Procedure Call，Google远程过程调用）是一个现代开源高性能远程过程调用(RPC)框架，可以在任何环境中运行。它由Google开发，旨在帮助开发人员更轻松地构建分布式应用，特别是当代码可能在不同地方运行的时候。 gRPC是一个高性能、开源和通用的RPC框架，它基于HTTP/2设计，并支持多种编程语言和平台。 随着其开源和广泛应用，gRPC已成为云原生计算基金会(CNCF)的一个孵化项目，被大量组织和企业采用。
基于Java+SpringMvc+Vue技术智慧校园系统设计与实现--60页及以上论文参考
mr_lili_111的博客
07-05 705
Java是一种面向对象的编程语言，目前由美国Oracle公司开发。自1995年上线以来，已经广泛应用于Web开发、桌面应用开发等多个领域。Java语言的特点包括：1、面向对象：Java提供了类、接口和继承等面向对象的特性，支持单继承和多接口继承，以及动态绑定。2、分布式：Java支持Internet应用的开发，提供了网络应用编程接口(java.net)，支持RMI(远程方法激活)机制，适合开发分布式应用。3、健壮性：Java的强类型机制、异常处理、垃圾自动收集等特性保证了程序的健壮性。
Spring相关面试题（四）
m0_73179389的博客
07-06 473
接口实现XML配置注解实现。
构建安全稳定的应用：SpringSecurity实用指南
zhugedali_的博客
07-04 692
它涵盖了认证（Authentication）、授权（Authorization）、防止常见的安全攻击等多个方面，适用于各种类型的应用，包括 Web 应用、RESTful 服务、微服务等。- 生成认证对象：认证成功后，创建包含用户信息、角色和权限的 Authentication 对象，并存储在安全上下文中。- 加载用户角色和权限：除了基本的用户信息，还包括用户所拥有的角色和权限。- 认证请求处理：根据配置的认证方式，对用户提交的认证信息进行验证。
springboot封装请求参数json的源码解析
g3230863的博客
07-04 241
springboot封装请求参数json的源码解析
Spring Security6.3.0版本出现无法解析符号
Rverdoser的博客
07-03 245
检查配置：确保Spring Security的配置没有错误，比如正确配置了SecurityFilterChain或者自定义的SecurityConfigurer。Spring Security 6.3.0版本出现“无法解析的符号”错误通常意味着项目中缺少了必要的类或者资源，或者可能是因为项目的依赖关系配置不正确。检查环境：确保你的构建环境（如Maven或Gradle的版本）支持Spring Security 6.3.0版本。查看错误日志：仔细查看IDE的错误日志或控制台输出，了解无法解析的符号具体是什么。
「Java开发指南」如何用MyEclipse完成Spring Web Flow 2.0搭建？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
07-04 456
本教程将引导开发者如何使用Spring Annotator实现Spring控制器，欢迎下载最新版IDE体验！
Spring 6.1.10版本源码编译
訾尤的博客
07-05 315
spring 6.1.10源码编译
Spring：Spring框架的发展历程与学习指南
永远保持随时离开的技术能力！
07-05 437
Spring框架的发展历程与学习指南
【SpringBoot3】使用Jasypt加密数据库用户名、密码等敏感信息
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
07-03 983
使用Jasypt（Java Simplified Encryption）进行数据加密和解密主要涉及几个步骤，包括引入依赖、配置加密密码、加密敏感信息、将加密信息存储到配置文件中，以及应用程序启动时自动解密。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值