分类 java 下的文章

2024-09-04

Tomcat的整体架构可以概括为连接器和容器的模式，连接器负责接收请求并将其转发到容器处理，容器则负责处理请求并响应。

以下是Tomcat的核心组件的概述：

连接器（Connectors）：负责处理网络通信，可以基于不同协议（如HTTP/1.1，AJP）提供服务。
容器（Containers）：容器用于处理请求，Tomcat有四种容器类型：Engine、Host、Context和Wrapper，层次结构为Engine包含Host，Host包含Context，Context包含Wrapper。
服务（Service）：组合一个或多个连接器及一个引擎，提供完整的web服务功能。
引擎（Engine）：处理特定服务的请求，可以包含多个虚拟主机。
日志记录（JULI）：Tomcat自带的日志系统，记录运行过程中的信息。

以下是一个简化的Tomcat架构示意图：

Tomcat Architecture

这个架构图中，我们可以看到连接器和容器之间的关系，以及它们如何与服务和引擎相连。这个图并没有展示所有组件，而是以一个高层次的视图来描述Tomcat的主要组件和它们之间的交互。

Spring boot 在启动时加载数据

2024-09-04

在Spring Boot中，你可以使用@PostConstruct注解的方法来在应用启动时加载数据。这个注解标记的方法会在类的构造函数和@Autowired注解之后执行。

以下是一个简单的例子，演示如何在Spring Boot应用启动时加载数据：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import javax.annotation.PostConstruct;
 
@SpringBootApplication
public class LoadDataApplication {
 
    private final MyService myService;
 
    public LoadDataApplication(MyService myService) {
        this.myService = myService;
    }
 
    @PostConstruct
    public void loadData() {
        // 在这里写加载数据的逻辑
        myService.loadInitialData();
    }
 
    public static void main(String[] args) {
        SpringApplication.run(LoadDataApplication.class, args);
    }
}
 
class MyService {
    public void loadInitialData() {
        // 实际加载数据的逻辑
        System.out.println("Data loaded");
    }
}

在这个例子中，MyService 类中的 loadInitialData 方法会在应用程序启动时被调用，并且由于它被标记为 @PostConstruct，它会在依赖注入完成之后执行。这是一个简单的方式来在Spring Boot应用程序启动时加载数据。

2024-09-04

由于篇幅限制，这里只提供一个简化版的示例代码来安装JDK。其他软件的安装可以参照以下步骤进行。




#!/bin/bash
# 安装JDK脚本示例
 
# 定义JDK版本和安装路径
JDK_VERSION="8u202"
JDK_INSTALL_PATH="/opt/jdk"
 
# 创建安装目录
mkdir -p $JDK_INSTALL_PATH
 
# 下载JDK
wget --no-check-certificate -c "https://download.oracle.com/otn-pub/java/jdk/${JDK_VERSION}+15/jdk-${JDK_VERSION}_linux-x64_bin.tar.gz" -O - | tar -xz -C $JDK_INSTALL_PATH
 
# 设置环境变量
echo "export JAVA_HOME=$JDK_INSTALL_PATH/jdk1.8.0_202" | tee -a ~/.bashrc
echo "export PATH=\$PATH:\$JAVA_HOME/bin" | tee -a ~/.bashrc
 
# 更新环境变量使其立即生效
source ~/.bashrc
 
# 输出JDK版本信息
echo "JDK installation complete"
java -version

这个脚本首先定义了JDK的版本和安装路径，然后创建了对应的目录，使用wget下载了JDK，并解压到指定目录。之后，它设置了JAVA\_HOME环境变量并将其添加到用户的.bashrc文件中，最后使用source命令使更改立即生效，并通过java -version命令确认JDK安装成功。

对于其他软件的安装，你可以参照这个脚本的模式，修改下载链接和解压缩参数来完成安装。例如，安装MySQL时，你需要下载相应的.tar.gz压缩包，然后解压缩到指定目录，并进行相关配置。安装Tomcat时，你需要下载.tar.gz压缩包，解压缩，并启动Tomcat服务。安装Redis时，你需要下载.tar.gz压缩包，解压缩，编译安装，并配置为服务。以此类推。

2024-09-04

在这个Activiti7系列的第二部分，我们将介绍如何使用Spring Security来保护Activiti7的REST API。我们将提供一个简单的Spring Boot应用程序，它整合了Spring Security和Activiti7 REST API。

以下是实现的主要步骤：

创建一个Spring Boot项目，并添加Activiti7 REST和Spring Security依赖。
配置Spring Security，包括用户的认证和授权。
配置Activiti7 REST API，使其能够使用Spring Security的认证和授权。
启动Spring Boot应用程序，并测试保护的REST API。

这个示例将提供一个简单的用户角色和权限模型，并且将使用内存中的用户存储。在实际应用中，你可能需要将用户存储与LDAP、数据库等集成。

源代码将包括Spring Boot应用程序的配置类，安全配置类，以及用于测试的REST API调用。

请注意，这个示例假定你已经有了Spring Boot和Activiti7的基础知识。如果你需要更详细的步骤或者代码实现，请告诉我。

SpringCloud微服务如何进行权限校验？

2024-09-04

在Spring Cloud微服务架构中实现权限验证通常涉及以下几个步骤：

使用Spring Security或者类似的框架来提供身份验证和授权服务。
使用OAuth2或JWT等协议来提供令牌。
在网关层（如Spring Cloud Gateway）进行权限验证。
在服务内部进行权限验证。

以下是一个简化的例子，使用Spring Security和JWT进行权限验证：

用户登录，验证成功后生成JWT Token。
网关层接收请求，验证JWT Token的合法性。
服务内部接口根据角色或权限对请求进行验证。

代码示例：

1. 引入依赖（Maven）




<!-- Spring Security -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- JWT -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2. 配置Spring Security




@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable() // 禁用CSRF
            .authorizeRequests()
            .anyRequest().authenticated() // 所有请求需要身份验证
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager())); // 添加JWT过滤器
    }
 
    // 其他配置...
}

3. 实现JWT过滤器




public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }
 
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request,
                                                HttpServletResponse response) throws AuthenticationException {
        // 从请求头中获取Token
        String token = request.getHeader("Authorization");
 
        // 如果请求头中没有Token，则不做处理
        if (token == null) return null;
 
        // 从Token中提取用户名和密码
        String username = Jwts.parser()
                              .setSigningKey("secret")
                              .parseClaimsJws(token.replace("Bearer ", ""))
                              .getBody()
                              .getSubject();
 
        // 如果没有获取到用户名，则不做处理
        if (username == null) return null;
 
        // 创建Authentication Token
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(
            username, null, new ArrayList<>());
 
        return authenticationManager.authenticate(authe

2024-09-04

创建一个基础的Spring Boot项目通常包括以下步骤：

使用Spring Initializr(https://start.spring.io/)来生成项目骨架。
配置application.properties或application.yml文件来设置项目属性。
配置日志记录。
配置数据库连接。
配置安全性，如Spring Security。
配置MVC特性，如视图解析器等。

以下是一些常见配置的示例：

application.properties 示例:




server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypass
spring.jpa.hibernate.ddl-auto=update
logging.level.root=WARN

application.yml 示例:




server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: myuser
    password: mypass
  jpa:
    hibernate:
      ddl-auto: update
logging:
  level:
    root: WARN

安全配置示例（使用Spring Security）:




@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }
 
    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER");
    }
}

MVC配置示例:




@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
        registry.addViewController("/hello").setViewName("hello");
        registry.addViewController("/login").setViewName("login");
    }
}

日志配置示例（使用Logback）:




<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <root level="info">
        <appender-ref ref="STDOUT" />

SpringBoot配置Swagger开启页面访问限制

2024-09-04

在Spring Boot项目中使用Swagger时，可以通过配置文件来限制对Swagger UI的访问。以下是一个使用Spring Security来限制对Swagger UI的访问的示例：

首先，在pom.xml中添加Spring Security依赖：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

接下来，在application.properties或application.yml中配置Swagger的基本路径访问权限：




# application.properties
springfox.documentation.swagger-ui.enabled=true

然后，配置Spring Security来保护Swagger UI路径。在WebSecurityConfigurerAdapter的实现中添加对Swagger UI的保护：




import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // 允许对Swagger UI的访问
            .authorizeRequests()
            .antMatchers("/swagger-ui.html").permitAll()
            .antMatchers("/v2/api-docs").permitAll()
            .antMatchers("/swagger-resources/**").permitAll()
            .antMatchers("/webjars/**").permitAll()
            // 其他所有请求都需要验证
            .anyRequest().authenticated()
            .and()
            // 禁用CSRF保护，因为Swagger不支持CSRF
            .csrf().disable();
    }
}

在上述配置中，我们通过.antMatchers()方法指定了对Swagger UI资源的访问权限，使用.permitAll()来允许它们被匿名访问。同时，关闭了CSRF保护，因为Swagger UI不支持CSRF令牌。

确保你的应用已经配置了用户源和用户详情服务，这样才能保护其他路径不受未授权访问。

以上代码仅供参考，具体实现可能需要根据实际项目需求进行调整。

Spring Cloud+Nacos 注册中心详解及开发示例

2024-09-04




import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class NacosDiscoveryController {
 
    private final DiscoveryClient discoveryClient;
 
    public NacosDiscoveryController(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }
 
    @GetMapping("/services")
    public Object services() {
        return discoveryClient.getServices();
    }
 
    @GetMapping("/instances")
    public Object instances() {
        return discoveryClient.getInstances("服务名");
    }
}

这段代码演示了如何在Spring Cloud应用中使用Nacos作为服务注册中心。DiscoveryClient接口提供了获取服务列表和实例信息的方法。/services端点返回所有已注册的服务列表，/instances返回特定服务的所有实例信息。在实际使用时，需要替换服务名为具体要查询的服务名称。

实战：Docker化Tomcat

2024-09-04




# 使用官方Java镜像作为基础镜像
FROM openjdk:8-jdk-alpine
 
# 定义维护者信息
LABEL maintainer="yourname@example.com"
 
# 定义工作目录
ENV CATALINA_HOME /usr/local/tomcat
ENV PATH $CATALINA_HOME/bin:$PATH
 
# 下载Tomcat并解压到工作目录
RUN wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz && \
    tar -xvf apache-tomcat-9.0.62.tar.gz && \
    mv apache-tomcat-9.0.62 $CATALINA_HOME && \
    rm apache-tomcat-*.tar.gz && \
    chmod +x $CATALINA_HOME/bin/*.sh
 
# 暴露8080端口
EXPOSE 8080
 
# 设置容器启动时运行Tomcat服务器
CMD ["catalina.sh", "run"]

这段代码提供了一个简洁的Dockerfile，用于构建一个基于Alpine Linux的Tomcat Docker镜像。它包括了维护者信息、工作目录的定义、Tomcat的下载和安装、环境变量的设置以及对外暴露端口的配置。最后，它通过CMD指令设置了容器启动时运行Tomcat服务的命令。这是一个实践中的例子，展示了如何将Tomcat容器化。

使用Spring Boot实现分布式事务

2024-09-04

在Spring Boot中实现分布式事务通常涉及到使用两阶段提交（2PC, Two-Phase Commit）协议或者基于消息的最终一致性实现。以下是一个使用Seata作为分布式事务解决方案的简单示例。

添加Seata依赖到pom.xml：




<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>

配置application.yml以使用Seata：




spring:
  cloud:
    alibaba:
      seata:
        tx-service-group: my_tx_group
        service:
          grouplist:
            default: 127.0.0.1:8091

在业务代码中使用@GlobalTransactional注解来标注需要参与分布式事务的方法：




import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class BusinessService {
 
    @Autowired
    private JdbcTemplate jdbcTemplate;
 
    @GlobalTransactional
    @Transactional
    public void purchaseCommodity(int userId, int commodityCode, int orderCount) {
        // 扣减用户账户余额
        jdbcTemplate.update("update account_tbl set balance = balance - ? where user_id = ?", orderCount * 10, userId);
        
        // 减少商品库存
        jdbcTemplate.update("update commodity_tbl set count = count - ? where code = ?", orderCount, commodityCode);
        
        // 记录订单
        jdbcTemplate.update("insert into orders_tbl (user_id, commodity_code, count) values (?, ?, ?)", userId, commodityCode, orderCount);
    }
}

确保所有涉及到的数据库操作都使用了Seata的分布式事务管理。在实际部署时，需要确保Seata Server正在运行并且客户端可以连接到它。