1. 首页
  2. 分类
  3. java
基于Spring Boot部署后端服务之简单流程
System
2024-09-05
所有,java



@SpringBootApplication
public class SimpleServiceApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(SimpleServiceApplication.class, args);
    }
}

这段代码是一个简单的Spring Boot应用程序入口点，它定义了一个带有@SpringBootApplication注解的主类。这个注解是一个复合注解，包含了@EnableAutoConfiguration、@ComponentScan和@Configuration。main方法中使用SpringApplication.run启动了这个Spring Boot应用程序。这是部署后端服务的一个基本流程。

- 阅读更多 -
企业电子招标采购系统源码Spring Cloud + Spring Boot + MybatisPlus + Redis + Layui + 前后端分离 + 二次开发
System
2024-09-05
所有,java

由于提供的信息较为模糊，并未给出具体的技术问题，我将提供一个使用Spring Cloud、Spring Boot、MyBatis Plus和Redis的简单示例。

以下是一个简单的Spring Cloud微服务的示例，它使用Spring Boot进行开发，MyBatis Plus进行数据库操作，Redis作为缓存系统。




// 引入相关依赖
// pom.xml
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.x.x</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- 其他依赖 -->
</dependencies>
 
// 实体类
@Data
@TableName("t_item")
public class Item {
    private Long id;
    private String name;
    // 其他字段
}
 
// Mapper接口
@Mapper
public interface ItemMapper extends BaseMapper<Item> {
    // 基本的CRUD操作已经由MyBatis Plus提供
}
 
// 服务接口和实现
public interface ItemService {
    Item getItemById(Long id);
}
 
@Service
public class ItemServiceImpl implements ItemService {
    @Autowired
    private ItemMapper itemMapper;
 
    @Override
    public Item getItemById(Long id) {
        return itemMapper.selectById(id);
    }
}
 
// 控制器
@RestController
@RequestMapping("/items")
public class ItemController {
    @Autowired
    private ItemService itemService;
 
    @GetMapping("/{id}")
    public Item getItem(@PathVariable Long id) {
        return itemService.getItemById(id);
    }
}
 
// 配置文件 application.properties
spring.redis.host=localhost
spring.redis.port=6379
 
// 启动类
@SpringBootApplication
@EnableCaching
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

这个简单的示例展示了如何使用Spring Cloud、Spring Boot、MyBatis Plus和Redis来构建一个基本的电子招标采购系统。在这个例子中，我们定义了一个名为Item的实体类，一个对应的Mapper接口，以及一个服务层ItemService和控制器ItemController。同时，我们展示了如何配置Redis作为缓存系统。这个例子提供了一个基本框架，开发者可以在此基础上根据具体需求进行扩展和完善。

- 阅读更多 -
spring cloud搭建elk
System
2024-09-05
所有,java

搭建ELK（Elasticsearch, Logstash, Kibana）的基本步骤如下：

  1. 安装Elasticsearch:

    • 下载并解压Elasticsearch。
    • 运行Elasticsearch。

  2. 安装Logstash:

    • 下载并解压Logstash。
    • 创建Logstash配置文件，用于解析日志并将其发送到Elasticsearch。

  3. 安装Kibana:

    • 下载并解压Kibana。
    • 配置Kibana并指向Elasticsearch实例。
    • 运行Kibana。

  4. 配置Spring Cloud应用:

    • 在应用的logback.xml中配置Logstash作为Socket客户端。

以下是一个简化的logback.xml配置示例，其中包含Logstash的SocketAppender：




<configuration>
 
  <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashSocketAppender">
    <destination>localhost:4560</destination>
    <encoder class="net.logstash.logback.encoder.LogstashEncoder" />
  </appender>
 
  <root level="info">
    <appender-ref ref="LOGSTASH" />
  </root>
</configuration>

确保Logstash的配置文件logstash.conf正确指向Elasticsearch，并且Kibana的配置文件kibana.yml指向Elasticsearch实例。

Logstash配置文件logstash.conf示例：




input {
  tcp {
    port => 4560
    codec => json_lines
  }
}
 
output {
  elasticsearch {
    hosts => ["http://localhost:9200"]
    index => "spring-cloud-%{+YYYY.MM.dd}"
  }
}

Kibana配置文件kibana.yml示例：




server.port: 5601
server.host: "0.0.0.0"
elasticsearch.hosts: ["http://localhost:9200"]

完成这些步骤后，启动Elasticsearch、Logstash和Kibana。应用将其日志发送到Logstash，Logstash将这些日志索引到Elasticsearch，最后可以在Kibana中进行搜索和可视化。

- 阅读更多 -
SpringBoot3 集成 Shiro
System
2024-09-05
所有,java

Spring Boot 3 整合 Shiro 的步骤大致如下：

  1. 添加依赖：在 pom.xml 中添加 Shiro 和 Spring Boot 的相关依赖。



<dependencies>
    <!-- Shiro -->
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring</artifactId>
        <version>1.8.0</version>
    </dependency>
 
    <!-- 其他依赖 -->
</dependencies>
  1. 配置 Shiro：在 application.properties 或 application.yml 中配置 Shiro。



# Shiro 配置
shiro.sessionManager.globalSessionTimeout = 86400000
shiro.unauthorizedUrl = /unauthorized
  1. 创建 Shiro 配置类：配置 ShiroFilterFactoryBean，Realm 等。



@Configuration
public class ShiroConfig {
 
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 配置登录请求
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 配置权限不足时跳转的页面
        shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized");
        // 定义访问权限
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/admin/**", "authc");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }
 
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(customRealm());
        return securityManager;
    }
 
    @Bean
    public CustomRealm customRealm() {
        return new CustomRealm();
    }
}
  1. 创建 Realm 类：实现用户认证和授权。



public class CustomRealm extends AuthorizingRealm {
 
    @Autowired
    private UserService userService;
 
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取用户信息
        // 设置角色和权限
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.addRole("admin");
        simpleAuthorizationInfo.addStringPermission("user:delete");
        return simpleAuthorizationInfo;
    }
 
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        // 实现认证逻辑
        UsernamePasswordToken token = (
- 阅读更多 -
SpringBoot多数据源处理方案、多租户实战
System
2024-09-05
所有,java

在Spring Boot中实现多租户通常涉及到动态数据源的切换。以下是一个简化的例子，展示了如何在Spring Boot应用中实现多租户数据源的动态切换：




@Configuration
public class DataSourceConfig {
 
    @Bean
    public DataSourceRouting dynamicDataSource(@Qualifier("tenantDatabaseMap") Map<String, DataSource> tenantDatabaseMap) {
        return new DataSourceRouting(tenantDatabaseMap);
    }
 
    @Bean
    @Primary
    public TenantDatabaseContext tenantDatabaseContext() {
        return new TenantDatabaseContext();
    }
 
    @Bean
    public TenantDatabaseHandler tenantDatabaseHandler() {
        return new TenantDatabaseHandler();
    }
 
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dynamicDataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dynamicDataSource);
        return sqlSessionFactoryBean.getObject();
    }
 
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dynamicDataSource) {
        return new DataSourceTransactionManager(dynamicDataSource);
    }
}
 
public class DataSourceRouting implements DataSource {
 
    private final Map<String, DataSource> dataSourceMap;
    private DataSource currentDataSource;
 
    public DataSourceRouting(Map<String, DataSource> dataSourceMap) {
        this.dataSourceMap = dataSourceMap;
    }
 
    public void switchTenant(String tenantId) {
        currentDataSource = dataSourceMap.get(tenantId);
    }
 
    // Delegate data source methods to the current data source
    @Override
    public Connection getConnection() throws SQLException {
        return currentDataSource.getConnection();
    }
 
    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return currentDataSource.getConnection(username, password);
    }
 
    // ... other data source methods
}
 
public class TenantDatabaseContext implements ApplicationContextAware {
 
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
 
    public static void setCurrentTenant(String tenantId) {
        contextHolder.set(tenantId);
    }
 
    public static String getCurrentTenant() {
        return contextHolder.get();
    }
 
    public static void clear() {
        contextHolder.remove();
    }
 
    // ... ApplicationContextAware implementation
}
 
public class TenantDatabaseHandl
- 阅读更多 -
使用inno将tomcat打包成exe安装包（可以提示重复安装）
System
2024-09-05
所有,java

为了将Tomcat打包成可执行的安装程序（EXE），并能够处理重复安装的情况，你可以使用Inno Setup这个免费的安装制作工具。以下是一个简单的Inno Setup脚本示例，用于打包Tomcat并安装到Windows系统上。




; 脚本文件: TomcatInstall.iss
; 打包Tomcat为EXE安装程序
 
#define MyAppName "Apache Tomcat"
#define MyAppVersion "9.0.62"
#define MyAppPublisher "Apache Software Foundation"
#define MyAppURL "http://tomcat.apache.org/"
#define MyAppExeName "tomcat9.exe"
 
[Setup]
; 注意: AppId的GUID在每个程序中都应该是唯一的
AppId={{E177D05E-9A72-4E2F-881D-D1E5738C2E5E}
AppName={#MyAppName}
AppVersion={#MyAppVersion}
AppVerName={#MyAppName} {#MyAppVersion}
AppPublisher={#MyAppPublisher}
AppPublisherURL={#MyAppURL}
AppSupportURL={#MyAppURL}
AppUpdatesURL={#MyAppURL}
DefaultDirName={autopf}\{#MyAppName}
DefaultGroupName={#MyAppName}
InfoBeforeFile=D:\path\to\preinstall.txt
OutputDir=D:\path\to\output
OutputBaseFilename=TomcatSetup
Compression=lzma
SolidCompression=yes
 
[Files]
Source: "D:\path\to\apache-tomcat-#{MyAppVersion}-windows-x64.zip"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
; 添加其他必要的文件或目录到安装程序
 
[Icons]
Name: "{group}\{#MyAppName}"; Filename: "{app}\bin\{#MyAppExeName}"
Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
 
[Run]
Filename: "{app}\bin\{#MyAppExeName}"; Parameters: "install"; Flags: nowait postinstall skipifsilent
 
[Code]

在这个脚本中，你需要替换以下内容：

  • D:\path\to\apache-tomcat-#{MyAppVersion}-windows-x64.zip 是Tomcat压缩包的路径。
  • D:\path\to\preinstall.txt 是一个可选的文本文件，显示在安装前。
  • D:\path\to\output 是输出目录，用于存放最终的安装包。
  • #define MyAppName, #define MyAppVersion, 和其他#define指令中的值应该替换为Tomcat的实际版本和发布信息。

要处理重复安装，你可以在[Code]段中使用自定义的逻辑。例如，你可以检查是否已经有一个Tomcat实例安装在系统上，如果是，则提示用户不允许重复安装。

请注意，这个脚本是一个基础示例，你可能需要根据你的具体需求进行调整。例如，你可能需要添加其他的文件、设置安装前的条件检查、处理用户界面的事件、设置安装后的操作等。

- 阅读更多 -
Spring Cloud Seata 系列：Seata-Server （1.7.1）安装与配置（集成 Nacos）
System
2024-09-05
所有,java

以下是一个简化的Seata-Server (1.7.1)安装与配置的示例，集成Nacos作为配置中心和服务注册中心。

  1. 下载Seata-Server：



wget https://github.com/seata/seata/releases/download/v1.7.1/seata-server-1.7.1.tar.gz
tar -zxvf seata-server-1.7.1.tar.gz
cd seata-server-1.7.1/
  1. 修改配置文件 conf/file.conf 以使用Nacos作为配置中心：



store {
  mode = "nacos"
 
  nacos {
    serverAddr = "127.0.0.1:8848" # Nacos服务器地址
    namespace = "" # Nacos的命名空间，如果使用默认则不填写或者使用默认的命名空间id
    group = "SEATA_GROUP"
    username = "nacos-user" # Nacos登录用户名
    password = "nacos-password" # Nacos登录密码
  }
}
  1. 修改配置文件 conf/registry.conf 以使用Nacos作为服务注册中心：



registry {
  type = "nacos"
 
  nacos {
    serverAddr = "127.0.0.1:8848" # Nacos服务器地址
    namespace = "" # Nacos的命名空间，如果使用默认则不填写或者使用默认的命名空间id
    group = "SEATA_GROUP"
    cluster = "default"
    username = "nacos-user" # Nacos登录用户名
    password = "nacos-password" # Nacos登录密码
  }
}
  1. 启动Seata-Server：



sh bin/seata-server.sh -p 8091 -h 127.0.0.1 -m file

以上命令启动Seata-Server，使用8091端口，并加载本地配置文件。

确保你的Nacos服务正在运行，并且配置了Seata的配置。

注意：

  • 请替换 serverAddr 为你的Nacos服务器的实际地址。
  • 如果Nacos启用了用户名和密码认证，请确保提供正确的用户名和密码。
  • 启动Seata-Server时可以指定不同的端口（-p 参数）和IP地址（-h 参数）。
  • 指定配置加载模式（-m 参数），可以是file、nacos、apollo、zk、consul、etcd3等。
- 阅读更多 -
Spring Boot中使用自定义注解+AOP实现权限校验
System
2024-09-05
所有,java



import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class PermissionAspect {
 
    // 定义切点，匹配带有@PermissionCheck注解的方法
    @Pointcut("@annotation(PermissionCheck)")
    public void permissionCheckPointcut() {
    }
 
    // 环绕通知，在匹配的方法执行前后进行权限检查
    @Around("permissionCheckPointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 执行权限检查逻辑
        if (!checkPermission()) {
            // 如果权限检查失败，则抛出权限异常或者其他逻辑处理
            throw new PermissionException("无权访问");
        }
        // 如果权限检查通过，继续执行原方法
        return joinPoint.proceed();
    }
 
    // 模拟权限检查方法，实际应用中需要替换为具体的权限检查逻辑
    private boolean checkPermission() {
        // 这里只是示例，实际应用中需要查询数据库或者调用权限服务进行权限校验
        // 返回true表示有权限，返回false表示无权限
        return true;
    }
}
 
// 自定义注解
import java.lang.annotation.*;
 
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PermissionCheck {
}
 
// 权限异常类
public class PermissionException extends RuntimeException {
    public PermissionException(String message) {
        super(message);
    }
}

在这个例子中，我们定义了一个自定义注解@PermissionCheck，然后使用Aspect切面和@Around注解来创建一个环绕通知，在目标方法执行前后进行权限检查。如果权限检查失败，则抛出PermissionException异常。这个例子展示了如何在Spring Boot应用中使用AOP和自定义注解来实现一个简单的权限检查系统。

- 阅读更多 -
Spring Cloud: OpenFeign 超时重试机制
System
2024-09-05
所有,java



@Configuration
public class FeignConfig {
 
    @Bean
    public Retryer feignRetryer() {
        return new Retryer.Default(100, TimeUnit.SECONDS.toMillis(1), 5);
    }
}

这段代码定义了一个Feign的重试器配置，它使用了Feign默认提供的重试器，并且设置了初始间隔时间为100毫秒，最大间隔时间为1秒，最大重试次数为5次。这样，当Feign客户端调用服务出现超时时，会进行重试。

- 阅读更多 -
SpringBoot接口防抖（防重复提交）
System
2024-09-05
所有,java

在Spring Boot中实现接口防抖，可以通过自定义注解和拦截器来实现。以下是一个简单的示例：

  1. 自定义注解AntiDingding：



@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AntiDingding {
    long timeout() default 5000;
}
  1. 创建拦截器AntiDingdingInterceptor：



@Component
public class AntiDingdingInterceptor implements HandlerInterceptor {
 
    private final Map<String, Long> cache = new ConcurrentHashMap<>();
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            AntiDingding antiDingding = method.getAnnotation(AntiDingding.class);
            if (antiDingding != null) {
                String key = getKey(request);
                Long lastTime = cache.get(key);
                long currentTime = System.currentTimeMillis();
                if (lastTime != null && currentTime - lastTime < antiDingding.timeout()) {
                    // 如果在指定的时间内重复提交，则返回false，不执行方法
                    return false;
                }
                cache.put(key, currentTime);
            }
        }
        return true;
    }
 
    private String getKey(HttpServletRequest request) {
        // 根据实际情况生成唯一的key，例如可以使用用户ID、请求的URL等
        return request.getRequestURI();
    }
}
  1. 注册拦截器AntiDingdingInterceptor：



@Configuration
public class WebConfig implements WebMvcConfigurer {
 
    @Autowired
    private AntiDingdingInterceptor antiDingdingInterceptor;
 
    @Override
    public void addInterceptors(InterceptorRegistry
- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号