简历技能之SpringBoot常用注解
简历技能之SpringBoot常用注解
今日目标
- SpringBoot框架开发项目过程中,常用的注解 🍐
- 剖析Springboot的底层原理 🍐 🚀
知识储备
- 已经完成springBoot框架创建项目或者使用若以框架开发一个表的增删改查业务
今日初始代码下载42kb
1. SpringBoot开发常用注解 ❤️
SpringBoot开发常用注解
实例化相关:
➡️ 1. @Configuration
: 用于标记一个类,指示它包含一个或多个bean的定义。通常用于配置类,其中定义了应用程序的Bean配置。
@Configuration
public class SwaggerConfig
{
/** 系统基础配置 */
@Autowired
private RuoYiConfig ruoyiConfig;
/** 是否开启swagger */
@Value("${swagger.enabled}")
private boolean enabled;
}
Configuration注解源码 👇
@Component
public @interface Configuration {
@AliasFor(
annotation = Component.class
)
String value() default "";
boolean proxyBeanMethods() default true;
}
➡️ 2. @RestController
: 用于标记一个类,指示它是一个控制器类,用于处理HTTP请求并返回RESTful响应。
@RestController
@RequestMapping("/bkuser/info")
public class BkUserController extends BaseController
{
@Autowired
private IBkUserService bkUserService;
}
@RestController
注解源码 👇
@Controller
@ResponseBody
public @interface RestController {
@AliasFor(
annotation = Controller.class
)
String value() default "";
}
➡️ 3. @Bean
: 用于标记一个方法,告诉Spring容器,该方法返回一个bean对象,可以被Spring管理和注入到其他组件中。
@Configuration
public class DruidConfig{
@Bean
@ConfigurationProperties("spring.datasource.druid.master")
public DataSource masterDataSource(DruidProperties druidProperties)
{
DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
return druidProperties.dataSource(dataSource);
}
}
@Bean
注解源码
public @interface Bean {
@AliasFor("name") //bean的名字
String[] value() default {};
@AliasFor("value") //bean的名字
String[] name() default {};
}
➡️ 4. @SpringBootApplication
: 用于启动一个Spring Boot应用程序,并包含了多个注解的组合,包括@Configuration
、@ComponentScan
和@EnableAutoConfiguration
,它们一起配置和启动Spring Boot应用程序。
@SpringBootApplication
public class RuoYiApplication
{
public static void main(String[] args)
{
SpringApplication.run(RuoYiApplication.class, args);
}
}
@SpringBootApplication
注解源码
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
@AliasFor(
annotation = EnableAutoConfiguration.class
)
Class<?>[] exclude() default {};
}
➡️ 5. @Service
: 用于标记一个类,指示它是一个服务层组件,通常用于业务逻辑的实现。Spring会自动将这些类作为bean进行管理。
@Service
public class SysConfigServiceImpl implements ISysConfigService
{
@Autowired
private SysConfigMapper configMapper;
}
@Service
源码
@Component
public @interface Service {
@AliasFor(
annotation = Component.class
)
String value() default "";
}
注入相关:
➡️ 6. @Autowired
: 用于自动装配(按类型注入)Spring bean依赖。它可以应用于构造函数、成员变量、setter方法等,以将依赖注入到目标组件中。
@RestController
@RequestMapping("/bkuser/info")
public class BkUserController extends BaseController
{
@Autowired
private IBkUserService bkUserService;
}
➡️ 7. @Resource
: 用于依赖注入,通常与@Autowired
类似,但更具体,可以用于指定要注入的bean的名称,jdk包下的。
@RestController
public class CaptchaController
{
@Resource(name = "captchaProducer") //对应文本验证码
private Producer captchaProducer;
@Resource(name = "captchaProducerMath") //对应数字运算验证码
private Producer captchaProducerMath;
}
➡️ 8. @Value
: 用于将配置属性的值注入到bean中,通常用于注入外部配置属性。
@Configuration
public class SwaggerConfig
{
/** 是否开启swagger */
@Value("${swagger.enabled}")
private boolean enabled;
/** 设置请求的统一前缀 */
@Value("${swagger.pathMapping}")
private String pathMapping;
}
application.yml
代码
# Swagger配置
swagger:
# 是否开启swagger
enabled: true
# 请求前缀
pathMapping: /dev-api
Web相关:
➡️ 9. @RequestMapping
: 用于映射HTTP请求路径到控制器方法。它可以用于类级别和方法级别,指示哪个URL会触发相应的控制器方法。
@RestController
@RequestMapping("/bkuser/info")
public class BkUserController extends BaseController
{
@Autowired
private IBkUserService bkUserService;
}
@RequestMapping
源码
@Mapping
public @interface RequestMapping {
String name() default "";
@AliasFor("path")
String[] value() default {};
@AliasFor("value")
String[] path() default {};
}
➡️ 10. @GetMapping
, @PostMapping
, @DeleteMapping
, @PutMapping
: 这些注解是@RequestMapping
的特定版本,用于指示处理HTTP GET、POST、DELETE和PUT请求的控制器方法。
@GetMapping
源码👇
@RequestMapping(
method = {RequestMethod.GET}
)
public @interface GetMapping {
@AliasFor(
annotation = RequestMapping.class
)
}
➡️ 11. @RequestBody
@PathVariable
@RequestParam
的区别
@RequestBody
用于从请求体中获取数据,通常用于接收复杂数据类型,如JSON或XML格式的数据。
/**
* 新增客户
*/
@PostMapping
public AjaxResult add(@RequestBody BkUser bkUser)
{
return toAjax(bkUserService.insertBkUser(bkUser));
}
@PathVariable
用于从URL路径中提取数据,通常用于标识资源的特定实例。
/**
* 获取客户详细信息
*/
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id)
{
return success(bkUserService.selectBkUserById(id));
}
@RequestParam
用于从查询参数中获取数据,通常用于接收HTTP GET请求中的参数或HTTP POST请求中的表单参数。
localhost:8080/haha?name=zs&age=12
/**
* 头像上传
*/
@PostMapping("/avatar")
public AjaxResult avatar(@RequestParam("avatarfile") MultipartFile file) throws Exception
{
}
业务相关:
@PreAuthorize
: 通常与Spring Security一起使用,用于在方法级别进行访问控制,指定哪些用户或角色可以访问特定的方法。
/**
* 新增参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:add')")
@Log(title = "参数管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysConfig config)
{
if (!configService.checkConfigKeyUnique(config))
{
return error("新增参数'" + config.getConfigName() + "'失败,参数键名已存在");
}
config.setCreateBy(getUsername());
return toAjax(configService.insertConfig(config));
}
PreAuthorize注解的源码
package org.springframework.security.access.prepost;
public @interface PreAuthorize {
String value();
}
/**
* RuoYi首创 自定义权限实现,ss取自SpringSecurity首字母
*
* @author ruoyi
*/
@Service("ss")
public class PermissionService
{
/** 所有权限标识 */
private static final String ALL_PERMISSION = "*:*:*";
/** 管理员角色权限标识 */
private static final String SUPER_ADMIN = "admin";
private static final String ROLE_DELIMETER = ",";
private static final String PERMISSION_DELIMETER = ",";
/**
* 验证用户是否具备某权限
*
* @param permission 权限字符串
* @return 用户是否具备某权限
*/
public boolean hasPermi(String permission)
{
if (StringUtils.isEmpty(permission)){
return false;
}
LoginUser loginUser = SecurityUtils.getLoginUser();
if (StringUtils.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getPermissions()))
{
return false;
}
PermissionContextHolder.setContext(permission);
return hasPermissions(loginUser.getPermissions(), permission);
}
}
spring security配置代码
/**
* spring security配置
*
* @author ruoyi
*/
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter
{
/**
* 身份认证接口
*/
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception
{
auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());
}
}
@Log
: 可能是自定义的,用于标记需要记录日志的方法或类,以便跟踪应用程序的行为和调试。
/**
* 新增参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:add')")
@Log(title = "参数管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysConfig config)
{
}
/**
* 修改参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:edit')")
@Log(title = "参数管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysConfig config)
{
}
LogAspect切面类代码
/**
* 操作日志记录处理
*
* @author ruoyi
*/
@Aspect
@Component
public class LogAspect
{
private static final Logger log = LoggerFactory.getLogger(LogAspect.class);
/** 排除敏感属性字段 */
public static final String[] EXCLUDE_PROPERTIES = { "password", "oldPassword", "newPassword", "confirmPassword" };
/** 计算操作消耗时间 */
private static final ThreadLocal<Long> TIME_THREADLOCAL = new NamedThreadLocal<Long>("Cost Time");
/**
* 处理请求前执行
*/
@Before(value = "@annotation(controllerLog)")
public void boBefore(JoinPoint joinPoint, Log controllerLog)
{
TIME_THREADLOCAL.set(System.currentTimeMillis());
}
/**
* 处理完请求后执行
*
* @param joinPoint 切点
*/
@AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult)
{
handleLog(joinPoint, controllerLog, null, jsonResult);
}
/**
* 拦截异常操作
*
* @param joinPoint 切点
* @param e 异常
*/
@AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")
public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e)
{
handleLog(joinPoint, controllerLog, e, null);
}
}
Swagger API相关:
@Api
,@ApiOperation
,@ApiImplicitParams
,@ApiImplicitParam
,@ApiModel
,@ApiModelProperty
: 通常与Swagger(API文档生成工具)一起使用,用于描述和生成API文档。@Api
和@ApiOperation
用于类和方法级别的描述,@ApiImplicitParams
和@ApiImplicitParam
用于参数描述,而@ApiModel
和@ApiModelProperty
用于数据模型的描述。
- 类级别
@Api("用户信息管理")
@RestController
@RequestMapping("/test/user")
public class TestController extends BaseController
{
}
- 方法级别
@ApiOperation("获取用户列表")
@GetMapping("/list")
public R<List<UserEntity>> userList()
{
List<UserEntity> userList = new ArrayList<UserEntity>(users.values());
return R.ok(userList);
}
- 参数描述
@ApiOperation("获取用户详细")
@ApiImplicitParam(name = "userId", value = "用户ID", required = true, dataType = "int", paramType = "path", dataTypeClass = Integer.class)
@GetMapping("/{userId}")
public R<UserEntity> getUser(@PathVariable Integer userId)
{
//代码省略...
}
- 实体描述
@ApiModel(value = "UserEntity", description = "用户实体")
class UserEntity
{
@ApiModelProperty("用户ID")
private Integer userId;
@ApiModelProperty("用户名称")
private String username;
}
业务场景示例:
假设您正在开发一个电子商务网站的后端,可以应用上述注解如下:
@RestController
和@RequestMapping
用于创建产品控制器,处理产品相关的HTTP请求,如获取产品信息、添加产品、更新产品等。@Service
用于创建商品服务,其中包含业务逻辑,如价格计算、库存管理等。@PreAuthorize
用于限制对某些敏感操作(如删除商品)的访问,只有具备管理员角色的用户才能执行。@Api
和@ApiOperation
用于文档化API,以便Swagger生成API文档,帮助前端和其他开发人员理解如何使用您的API。@Log
可能用于记录关键操作的日志,以便监控和审计。
这些注解的使用可以帮助您构建健壮、文档化和安全的后端应用程序。
作业
🚩 1. 如果面试官问你SpringBoot开发过程中,有哪些注解,你可以结合上面的,以及业务说明一下
2. 集成jsencrypt实现密码加密传输方式
前端密码或者铭感信息加密传输
目前登录接口密码是明文传输,如果安全性有要求,可以调整成加密方式传输

代码操作
前端代码操作
- 修改前端
login.js
对密码进行rsa加密。点击查看代码图解
import { encrypt } from '@/utils/jsencrypt'
export function login(username, password, code, uuid) {
password = encrypt(password); //引入工具类,将密码进行加密
.........
}
Java后端代码操作
- 工具类sign包下添加RsaUtils.java,用于RSA加密解密。
package com.ruoyi.common.utils.sign;
import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
/**
* RSA加密解密
*
* @author ruoyi
**/
public class RsaUtils
{
// Rsa 私钥
public static String privateKey = "MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAqhHyZfSsYourNxaY"
+ "7Nt+PrgrxkiA50efORdI5U5lsW79MmFnusUA355oaSXcLhu5xxB38SMSyP2KvuKN"
+ "PuH3owIDAQABAkAfoiLyL+Z4lf4Myxk6xUDgLaWGximj20CUf+5BKKnlrK+Ed8gA"
+ "kM0HqoTt2UZwA5E2MzS4EI2gjfQhz5X28uqxAiEA3wNFxfrCZlSZHb0gn2zDpWow"
+ "cSxQAgiCstxGUoOqlW8CIQDDOerGKH5OmCJ4Z21v+F25WaHYPxCFMvwxpcw99Ecv"
+ "DQIgIdhDTIqD2jfYjPTY8Jj3EDGPbH2HHuffvflECt3Ek60CIQCFRlCkHpi7hthh"
+ "YhovyloRYsM+IS9h/0BzlEAuO0ktMQIgSPT3aFAgJYwKpqRYKlLDVcflZFCKY7u3"
+ "UP8iWi1Qw0Y=";
/**
* 私钥解密
*
* @param privateKeyString 私钥
* @param text 待解密的文本
* @return 解密后的文本
*/
public static String decryptByPrivateKey(String text) throws Exception
{
return decryptByPrivateKey(privateKey, text);
}
/**
* 公钥解密
*
* @param publicKeyString 公钥
* @param text 待解密的信息
* @return 解密后的文本
*/
public static String decryptByPublicKey(String publicKeyString, String text) throws Exception
{
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyString));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
byte[] result = cipher.doFinal(Base64.decodeBase64(text));
return new String(result);
}
/**
* 私钥加密
*
* @param privateKeyString 私钥
* @param text 待加密的信息
* @return 加密后的文本
*/
public static String encryptByPrivateKey(String privateKeyString, String text) throws Exception
{
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyString));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
byte[] result = cipher.doFinal(text.getBytes());
return Base64.encodeBase64String(result);
}
/**
* 私钥解密
*
* @param privateKeyString 私钥
* @param text 待解密的文本
* @return 解密后的文本
*/
public static String decryptByPrivateKey(String privateKeyString, String text) throws Exception
{
PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyString));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec5);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] result = cipher.doFinal(Base64.decodeBase64(text));
return new String(result);
}
/**
* 公钥加密
*
* @param publicKeyString 公钥
* @param text 待加密的文本
* @return 加密后的文本
*/
public static String encryptByPublicKey(String publicKeyString, String text) throws Exception
{
X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyString));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec2);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] result = cipher.doFinal(text.getBytes());
return Base64.encodeBase64String(result);
}
/**
* 构建RSA密钥对
*
* @return 生成后的公私钥信息
*/
public static RsaKeyPair generateKeyPair() throws NoSuchAlgorithmException
{
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(1024);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
String publicKeyString = Base64.encodeBase64String(rsaPublicKey.getEncoded());
String privateKeyString = Base64.encodeBase64String(rsaPrivateKey.getEncoded());
return new RsaKeyPair(publicKeyString, privateKeyString);
}
/**
* RSA密钥对对象
*/
public static class RsaKeyPair
{
private final String publicKey;
private final String privateKey;
public RsaKeyPair(String publicKey, String privateKey)
{
this.publicKey = publicKey;
this.privateKey = privateKey;
}
public String getPublicKey()
{
return publicKey;
}
public String getPrivateKey()
{
return privateKey;
}
}
}
Java后端代码操作
- 登录方法
SysLoginController.java
,对密码进行rsa解密。

// 关键代码 RsaUtils.decryptByPrivateKey(password)
@PostMapping("/login")
public AjaxResult login(@RequestBody LoginBody loginBody)
{
AjaxResult ajax = AjaxResult.success();
// 生成令牌
String token = loginService.login(loginBody.getUsername(),
RsaUtils.decryptByPrivateKey(loginBody.getPassword()), loginBody.getCode(), loginBody.getUuid());
ajax.put(Constants.TOKEN, token);
return ajax;
}
访问 http://localhost/login
登录页面。提交时检查密码是否为加密传输,且后台也能正常解密
作业
🚩 1. 如果面试官问你,请问你怎么保障前后端数据的安全性的?你尝试的回答一下。
- 思考下,如果后端传输数据给前端,怎么保障数据传输过程在安全性尼?
3. 完成PostgreSQL数据库的增删改查
前言
PostgreSQL 是一款成熟且备受推崇的开源关系型数据库管理系统(DBMS)。它以其卓越的功能性、可扩展性和稳定性而闻名于业界。
PostgreSQL 具有以下几个显著特点:
开源自由:作为开源软件,PostgreSQL 提供了自由的使用权,并且可以轻松地根据需要进行修改和定制。
强大而灵活的数据模型:PostgreSQL 支持多种数据类型,包括数值、字符串、日期/时间、布尔型、数组、JSON、XML 等,可以方便地满足各种数据存储需求。
高度可扩展和定制化:PostgreSQL 提供了丰富的扩展机制,允许用户自定义数据类型、索引类型、函数、触发器等,以满足特定应用程序的需求。
事务支持和并发控制:PostgreSQL 提供了 ACID(原子性、一致性、隔离性和持久性)事务支持,并采用多版本并发控制(MVCC)技术,实现高并发读写操作。
安全性和数据完整性:PostgreSQL 提供了灵活的认证和授权机制,支持 SSL 加密传输。同时,它还提供了完整性约束、触发器和外键等功能,确保数据的完整性和一致性。
本文主要讲解的是在docker环境环下安装
- 下载镜像
不指定具体版本的话,默认下载最新版镜像postgres:latest docker pull postgres:14.9
- 查看镜像

- 镜像运行容器
docker run --name postgres -e POSTGRES_PASSWORD=Abc1234% -p 15432:5432 -v /volume1/docker/postgres/data:/var/lib/postgresql/data -d postgres:14.9
参数说明:
--name postgres
:指定容器的名称;-e POSTGRES_PASSWORD=Abc1234%
:设置环境变量,这里为设定PostgreSQL数据库的密码;-p 15432:5432
:指定端口映射,前者为宿主机访问端口,后者为容器内端口。如果不指定端口映射,只有在容器内可以访问数据库,外部是无法访问的;-v /volume1/docker/postgres/data:/var/lib/postgresql/data
:v是volume的简写,即绑定一个卷,冒号前的路径为宿主机的路径(如果指定路径不存在会自动创建目录),冒号后为容器内路径。容器会把宿主机的目录映射到容器内的路径,这样容器运行中生成的数据实际上就是写到了宿主机的指定路径上,即使容器删除了,此路径的文件也不会删除,这样就做到了数据库的持久化存储。还可以通过docker volume提供的相关命令显式地创建volume,然后再挂载到容器上,这里不做介绍,请自行查询相关内容;-d
:表示后台运行容器;postgres:14.9
:表示镜像的名称,docker基于上步拉取的镜像创建出容器;
- 查看容器信息 docker ps命令可以查看运行中的容器信息,容器运行成功可以发现存在名为postgres的容器,状态为Up
docker ps
# 可以显示包括未运行的所有容器
docker ps -a
# 删除容器
docker rm 容器id

使用idea的database连接工具,连接测试

代码操作
CREATE TABLE users (
id serial PRIMARY KEY,
name VARCHAR(255),
description TEXT
);
INSERT INTO users (name, description)
VALUES
('张无忌', '九阳真经传人,与小龙女共闯江湖'),
('令狐冲', '独孤九剑宗师,情系岳灵珊'),
('杨过', '神雕侠侣,与小龙女相依为命'),
('郭靖', '神雕大侠,义薄云天'),
('黄蓉', '郭靖的妻子,智勇双全');

创建Mapper和测试类
@Mapper
public interface UserMapper {
/**
* 查询所有用户,然后返回一个Map,在测试类中测试
* @return
*/
@Select("select * from users")
List<Users> getUsers();
@Select("select * from users")
List<Map<String,Object>> getUsers2Map();
}
@SpringBootTest
class SpringPostgresqlDemoApplicationTests {
@Autowired
UserMapper userMapper;
@Test
void contextLoads() {
final List<Users> users = userMapper.getUsers();
System.out.println(users);
}
@Test
void contextLoads2() {
List<Map<String, Object>> users2Map = userMapper.getUsers2Map();
for (Map<String, Object> stringObjectMap : users2Map) {
System.out.println(stringObjectMap.get("id"));
System.out.println(stringObjectMap.get("name"));
System.out.println(stringObjectMap.get("description"));
}
}
}

将查出来的结果 转成doc
@Test
void contextLoads3() throws Exception {
List<Map<String, Object>> users2Map = userMapper.getUsers2Map();
for (Map<String, Object> stringObjectMap : users2Map) {
String filepath = WordUtil.generatorFilepath(stringObjectMap.get("id")+"", (String) stringObjectMap.get("name"));
FileOutputStream fos = new FileOutputStream(new File(filepath));
XWPFDocument document = WordUtil.getXwpfDocument((String) stringObjectMap.get("description"));
document.write(fos);
document.close();
fos.close();
}
}
4. docker安装neo4j中文版数据库
前言
Neo4j 是一款强大的图形数据库,Docker 版本为开发者提供了便捷的安装方式,同时可以使用浏览器客户端访问数据库,进行图形数据管理和查询。

Neo4j 适用于多种业务场景,如社交网络分析、推荐系统、知识图谱构建等。它的优点包括能够高效存储和查询关系型数据,以及提供直观的可视化工具。
与传统关系型数据库不同,Neo4j 是一种图形数据库,更适用于处理复杂的关系数据,具有出色的性能和可扩展性。
代码操作
使用以下命令从 Docker Hub 下载 Neo4j 镜像:
# 下载 Neo4j Docker 镜像
docker pull neo4jchina/neo4j-chs:latest
现在,您可以使用以下命令启动 Neo4j 容器。请替换 <your_password>
为您的数据库密码:
# 执行 docker images ls 查看所有镜像--->镜像名字
# 启动 Neo4j 容器
docker run -d --name neo4jchina -p 17473:7473 -p 17474:7474 -p 17687:7687 -v /volume1/docker/neo4j/data:/data -v /volume1/docker/neo4j/logs:/logs -v /volume1/docker/neo4j/conf:/var/lib/neo4j/conf -v /volume1/docker/neo4j/import:/var/lib/neo4j/import --env NEO4J_AUTH=neo4j/12345678 neo4jchina/neo4j-chs:latest
参数说明:
-d --name container_name
: -d表示容器后台运行 --name指定容器名字-p 17474:7474
:指定端口映射,前者为宿主机访问端口,后者为容器内端口。如果不指定端口映射,只有在容器内可以访问数据库,外部是无法访问的;-v /volume1/docker/neo4j/data:/data
:v是volume的简写,即绑定一个卷,冒号前的路径为宿主机的路径(如果指定路径不存在会自动创建目录),冒号后为容器内路径。容器会把宿主机的目录映射到容器内的路径,这样容器运行中生成的数据实际上就是写到了宿主机的指定路径上,即使容器删除了,此路径的文件也不会删除,这样就做到了数据库的持久化存储。还可以通过docker volume提供的相关命令显式地创建volume,然后再挂载到容器上,这里不做介绍,请自行查询相关内容;-v /volume1/docker/neo4j/logs:/logs
//挂载日志目录-v /volume1/docker/neo4j/conf:/var/lib/neo4j/conf
//挂载配置目录-v /volume1/docker/neo4j/import:/var/lib/neo4j/import
//挂载数据导入目录--env NEO4J_AUTH=neo4j/123456
//设定数据库的名字的访问密码neo4jchina/neo4j-chs:latest
: 镜像名字
注意:
org.neo4j.commandline.admin.security.exception.InvalidPasswordException: A password must be at least 8 characters.
这个错表示:密码至少8个字符

打开浏览器,并访问以下地址:http://localhost:17474
您将看到 Neo4j 浏览器客户端登录界面。使用用户名 neo4j 和您在第三步中设置的密码登录。


点击,根据教程,插入数据
总结
本指南介绍了如何使用 Docker 安装 Neo4j中文版,并使用浏览器客户端访问数据库。Neo4j 是一个功能强大的图形数据库,适用于多种业务场景,具有直观的可视化工具,方便数据管理和查询。
请注意,这只是一个入门指南。Neo4j 具有丰富的功能和强大的查询语言(Cypher),您可以深入学习以充分利用其潜力。祝您愉快地使用 Neo4j 构建和查询图形数据!
5. docker安装mysql数据库
前言
MySQL 是一个开源的关系型数据库管理系统,Docker 提供了一种便捷的方式来安装和运行 MySQL 数据库。本指南将介绍如何使用 Docker 安装 MySQL 并进行基本配置。
MySQL 适用于多种业务场景,如Web应用程序、企业级应用程序、数据仓库等。它的优点包括稳定性、高性能和广泛的社区支持。
与传统的本地安装方式不同,Docker 安装 MySQL 具有更高的灵活性和隔离性,可以轻松部署多个数据库实例并进行管理。
代码操作
使用以下命令从 Docker Hub 下载 MySQL 镜像:
# 下载 MySQL Docker 镜像(请替换 <version> 为所需版本 如latest)
docker pull mysql:<version>
现在,您可以使用以下命令启动 MySQL 容器。请替换 <your_password>
为您的数据库密码:
# 启动 MySQL 容器
docker run \
--name mysql \
-d \
-p 13306:3306 \
--restart unless-stopped \
-v /volume1/docker/mysql/log:/var/log/mysql \
-v /volume1/docker/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=12345678 \
mysql:latest

如果安装失败,执行
docker rm -f 容器ID
删除容器重新安装
设置远程访问权限
- 使用
docker exec -it 容器ID /bin/bash
进入命令行 - 使用
mysql -uroot -p1234578
命令,登录数据库 - 使用
alter user 'root'@'%' identified with mysql_native_password by '12345678';
修改远程登录权限 - 使用
flush privileges;
刷新权限
- 使用

- 使用navicat登录数据库

总结
本指南介绍了如何使用 Docker 安装 MySQL 数据库,并进行基本的配置和访问。MySQL 是一个强大的关系型数据库管理系统,适用于各种业务场景。
请注意,这只是一个入门指南。MySQL 具有丰富的功能和强大的查询语言(SQL),您可以深入学习以充分利用其潜力。在生产环境中,还需要考虑数据库的备份和性能优化等问题。祝您愉快地使用 MySQL!
5. Docker搭建Redis集群
前言
Redis 集群是 Redis 数据库的分布式版本,通过多个节点协同工作,提供高可用性和扩展性。
Redis 集群适用于需要快速缓存和处理大量数据的应用,如高流量的 Web 应用程序、会话存储和排行榜。
与单节点 Redis 不同,Redis 集群可以分布在多个节点上,提供数据冗余和负载均衡。
代码操作
步骤
- 第一步 - 下载 Redis Docker 镜像
- 第二步 - 创建 Redis 集群容器
- 第三步 - 构建 Redis 集群
- 第四步 - 检查 Redis 集群状态
- 第五步 - 使用 Redis 集群
首先,确保你已安装 Docker。然后,使用以下命令从 Docker Hub 下载 Redis 镜像:
docker pull redis
创建一个 Redis 集群需要至少 6 个节点。以下示例使用 6 个容器作为节点。
docker run -d --name redis-node1 redis
docker run -d --name redis-node2 redis
docker run -d --name redis-node3 redis
docker run -d --name redis-node4 redis
docker run -d --name redis-node5 redis
docker run -d --name redis-node6 redis
在容器中执行以下命令来构建 Redis 集群。
docker exec -it redis-node1 redis-cli --cluster create \
172.17.0.2:6379 172.17.0.3:6379 172.17.0.4:6379 \
172.17.0.5:6379 172.17.0.6:6379 172.17.0.7:6379 \
--cluster-replicas 1
请注意,IP 地址和端口号应根据你的容器配置进行调整。
检查集群状态以确保一切正常运行。
docker exec -it redis-node1 redis-cli cluster nodes
现在,你可以使用 Redis 集群了。连接到任何节点,它们将自动重定向到正确的主节点。
docker exec -it redis-node1 redis-cli
总结
通过 Docker 创建 Redis 集群,你可以轻松实现高可用性和扩展性,适用于大规模的数据缓存需求。请注意,配置和管理 Redis 集群需要谨慎,特别是在生产环境中。