2024-09-02

WebMvcConfigurationSupport是Spring MVC框架中提供的一个用于定制Spring MVC配置的类。如果你想要添加自定义拦截器,你可以通过继承WebMvcConfigurationSupport并覆盖其addInterceptors方法来实现。

以下是一个如何使用addInterceptor方法添加自定义拦截器的例子:




import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import org.springframework.web.servlet.HandlerInterceptor;
 
@Configuration
public class WebConfig extends WebMvcConfigurationSupport {
 
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        HandlerInterceptor customInterceptor = new HandlerInterceptor() {
            @Override
            public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                // 在请求处理之前进行调用(Controller方法调用之前)
                return true; // 如果返回false,则停止流程,api不会被调用
            }
 
            @Override
            public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
                // 请求处理之后进行调用,但是在视图被渲染之前(Controller方法调用之后)
            }
 
            @Override
            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
                // 在整个请求结束之后调用,也就是在DispatcherServlet渲染了视图执行
            }
        };
 
        registry.addInterceptor(customInterceptor)
                .addPathPatterns("/**"); // 添加拦截路径
                //.excludePathPatterns("/login", "/error"); // 添加排除路径
    }
}

在这个例子中,我们定义了一个customInterceptor,它实现了HandlerInterceptor接口。然后我们将其注册到Spring MVC配置中,并指定所有路径/**都将被这个拦截器拦截。你也可以通过excludePathPatterns方法排除特定的路径。这样,每次请求/**路径时,都会先执行customInterceptor中的方法。

2024-09-01



import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
@Controller
@SessionAttributes("userInfo") // 将userInfo存储在session中
public class UserController {
 
    // 处理请求的方法,并获取请求参数
    @RequestMapping("/greeting")
    public String greeting(@RequestParam(name = "name", required = false, defaultValue = "World") String name, Model model) {
        model.addAttribute("name", name); // 将参数添加到模型中
        return "greeting"; // 返回视图名称
    }
 
    // 处理请求的方法,并获取session中的数据
    @RequestMapping("/welcome")
    public String welcome(Model model, UserInfo userInfo) {
        model.addAttribute("userInfo", userInfo); // 将userInfo添加到模型中
        return "welcome"; // 返回视图名称
    }
}
 
// 用户信息类
class UserInfo {
    private String username;
    private String email;
 
    // getter和setter方法
    // ...
}

在这个例子中,greeting方法通过@RequestParam获取了一个请求参数name,并将其添加到了模型中。welcome方法没有获取请求参数,而是从session中获取了UserInfo对象,并将其添加到模型中。这两种方式展示了如何在Spring MVC中获取请求参数和共享用户信息。

2024-09-01

要通过Nginx访问同一Tomcat服务器中的多个Spring MVC应用,你需要在Nginx中配置多个代理服务器,每个代理服务器指向不同的Tomcat应用。

以下是一个简单的Nginx配置示例,假设你有两个Spring MVC应用程序运行在同一个Tomcat服务器的不同路径下:




http {
    upstream app1 {
        server tomcat_server:8080;
    }
 
    upstream app2 {
        server tomcat_server:8080;
    }
 
    server {
        listen 80;
 
        location /app1/ {
            proxy_pass http://app1;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
 
        location /app2/ {
            proxy_pass http://app2;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

在这个配置中,upstream 指令定义了两个后端服务器群组,app1app2,分别对应两个不同的Spring MVC应用。然后在 server 块中,通过 location 指令定义了两个不同的代理路径,/app1//app2/,分别指向两个不同的应用。

确保你的Spring MVC应用程序部署在Tomcat的不同路径下,例如 /app1/app2,并且Nginx监听的端口(这里是80)与你的域名或IP绑定。

记得在配置后重新加载或重启Nginx使配置生效:




sudo nginx -s reload
2024-09-01



import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
@SpringBootApplication // 标注这是一个Spring Boot应用
public class HelloWorldApplication {
 
    // main方法,程序入口
    public static void main(String[] args) {
        SpringApplication.run(HelloWorldApplication.class, args);
    }
 
    // 内部类,实现WebMvcConfigurer接口,配置控制器
    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {
                registry.addViewController("/").setViewName("index");
            }
        };
    }
}

这段代码定义了一个简单的Spring Boot应用程序,它使用@SpringBootApplication注解来启用Spring Boot的自动配置。同时,它使用了一个内部类实现了WebMvcConfigurer接口,将根URL映射到名为"index"的视图。这是一个入门级的Spring Boot和Spring MVC的示例,展示了如何将请求映射到控制器并返回视图。

2024-09-01

MVCC,全称Multi-Version Concurrency Control,即多版本并发控制。它是一种并发控制机制,用于数据库管理系统中防止脏读、不可重复读和幻读等问题。

MVCC的实现方式通常依赖于数据库的事务ID和行的时间戳。每个事务在读取数据时都会获取一个事务ID,而数据在每次被修改时都会与事务ID关联。读操作会读取该事务ID之前的数据版本。

以下是一个简化的MVCC实现示例:




-- 假设有一个表格users,包含id, name, data_version字段
-- data_version用于记录数据版本
 
-- 插入数据时,data_version初始化为0
INSERT INTO users (id, name, data_version) VALUES (1, 'Alice', 0);
 
-- 开启事务1,更新用户名
BEGIN;
SELECT id, name, data_version FROM users WHERE id = 1; -- 读取事务ID为1的数据版本
UPDATE users SET name = 'Bob', data_version = data_version + 1 WHERE id = 1; -- 更新数据版本
COMMIT; -- 事务1提交
 
-- 开启事务2,尝试读取用户名
BEGIN;
SELECT id, name, data_version FROM users WHERE id = 1; -- 读取事务ID为2的数据版本,此时能看到更新后的数据
COMMIT; -- 事务2提交
 
-- 在事务2提交后,事务1的更新对事务2不可见,因此不会产生脏读、不可重复读和幻读等问题

在实际的数据库系统中,如MySQL的InnoDB引擎,通常会用Undo日志和Read View来实现MVCC。Undo日志记录了每个版本的数据,而Read View是一个快照,记录了某个时刻系统中活跃的事务ID。通过这种方式,MVCC保证了在并发读写数据时,事务之间不会互相影响,从而保持数据的一致性和隔离性。

2024-09-01



import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
 
@SpringBootTest
@AutoConfigureMockMvc
public class ExampleControllerTest {
 
    @Autowired
    private MockMvc mockMvc;
 
    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        this.mockMvc.perform(MockMvcRequestBuilders.get("/hello"))
            .andDo(MockMvcResultHandlers.print())
            .andExpect(MockMvcResultMatchers.status().isOk())
            .andExpect(MockMvcResultMatchers.content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(MockMvcResultMatchers.jsonPath("$.message").value("Hello, World!"));
    }
}

这段代码演示了如何使用Spring Boot的@SpringBootTest@AutoConfigureMockMvc注解来进行集成测试,并使用MockMvc来发起GET请求,检查响应状态、内容类型和JSON内容。

2024-08-30



import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
 
@Controller
public class HelloController {
 
    // 处理"/hello"的GET请求
    @GetMapping("/hello")
    @ResponseBody // 表示返回的数据不是视图模板,而是直接写入HTTP响应体
    public String hello(@RequestParam(name = "name", required = false, defaultValue = "World") String name) {
        return "Hello, " + name + "!";
    }
}

这段代码定义了一个简单的Spring Web MVC控制器,它处理"/hello"的GET请求,并返回一个字符串。@RequestParam注解用于获取请求参数,可以指定参数名、是否必需以及默认值。@ResponseBody注解表明返回的字符串直接写入HTTP响应体,而不是解析为视图名称。这是一个基本的Spring MVC控制器示例,适用于学习和入门级别的指导。

2024-08-30

创建SSM项目并配置Redis使用RESP协议和AOF持久化的步骤如下:

  1. 创建Maven项目并添加Spring、Spring MVC和MyBatis依赖。
  2. 配置web.xml,添加Spring和Spring MVC的监听器和servlet。
  3. 添加MyBatis配置文件和Mapper接口。
  4. 配置Redis客户端,使用Jedis,并添加Redis依赖。
  5. 配置Redis的连接和操作类。
  6. 配置Redis的RESP协议和AOF持久化。

以下是相关的配置文件和代码示例:

pom.xml(依赖配置):




<dependencies>
    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.20</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.20</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.10</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.10</version>
    </dependency>
    <!-- Redis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>4.2.0</version>
    </dependency>
</dependencies>

applicationContext.xml(Spring配置):




<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">
 
    <!-- DataSource Configuration -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
    </bean>
 
    <!-- SqlSessionFactory Configuration -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
 
    <!-- MapperScannerConfigurer Configuration -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.example.mapper"/>
    </bean>
 
</beans>

mybatis-config.xml(MyBatis配置):




<configuration>
    <mappers>
        <mapper resource="com/ex
2024-08-30



// 导入Spring MVC和Spring核心的相关注解
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
 
// 使用@Controller注解标识该类为控制器
@Controller
public class HelloWorldController {
 
    // 使用@RequestMapping注解来映射Web请求,这里映射的是根路径
    // 使用method属性来指定请求方式,这里指定为GET请求
    @RequestMapping(value = "/", method = RequestMethod.GET)
    // 使用@ResponseBody注解来指示返回的数据不是视图路径,而是直接响应数据
    @ResponseBody
    public String hello() {
        return "Hello, Spring MVC!"; // 返回字符串作为响应
    }
}

这段代码定义了一个简单的Spring MVC控制器,它处理根路径的GET请求,并返回一个文本消息。这展示了如何使用Spring MVC的注解来简化Web开发,并遵循MVC架构的最佳实践。

2024-08-30

Spring MVC的工作流程可以概括为以下步骤:

  1. 用户发送请求至前端控制器(DispatcherServlet)。
  2. DispatcherServlet接收请求并处理。
  3. DispatcherServlet查询处理器映射器(HandlerMapping)找到处理请求的Controller。
  4. DispatcherServlet将请求委托给Controller。
  5. Controller接收请求并处理,处理完成后返回ModelAndView对象。
  6. DispatcherServlet查询视图解析器(ViewResolver)根据ModelAndView中的视图信息找到对应的视图。
  7. DispatcherServlet将执行结果渲染到视图上。
  8. 返回响应给用户。

具体的实现细节取决于具体的应用场景和配置,但以上步骤是Spring MVC基本工作流程的核心。

以下是一个简单的Spring MVC配置示例:

web.xml配置:




<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

Spring MVC配置文件(例如dispatcher-servlet.xml):




<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
 
    <context:component-scan base-package="com.example.controller" />
 
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>
 
</beans>

Controller示例:




@Controller
public class ExampleController {
    @RequestMapping(value = "/example", method = RequestMethod.GET)
    public ModelAndView exampleMethod() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("exampleView");
        modelAndView.addObject("message", "Hello, Spring MVC!");
        return modelAndView;
    }
}

在这个简单的例子中,我们配置了一个Servlet和一个视图解析器,并且创建了一个Controller。当用户访问/example时,Controller的exampleMethod会被调用,返回一个包含视图名称和消息的ModelAndView对象。