标签 mvc 下的文章

2024-09-05

Spring MVC是一种基于Java的实现了MVC设计模式的轻量级Web框架，它是Spring的一部分，用于构建web应用程序。

MVC模式指的是模型(Model)-视图(View)-控制器(Controller)模式，它将应用程序的不同部分分离开来，这样有助于管理复杂的应用程序并提高其可维护性。

Spring MVC的主要组件包括：

DispatcherServlet：前端控制器，用于处理所有请求，相当于转发器。
HandlerMapping：处理器映射，用于根据请求查找Handler。
HandlerAdapter：处理器适配器，用于支持多种类型的处理器。
Handler：处理器，即应用程序中用于处理请求的组件。
View Resolver：视图解析器，用于解析视图。
View：视图，即用于渲染结果的组件。

Spring MVC的工作流程大致如下：

用户发送请求至前端控制器(Dispatcher Servlet)。
前端控制器请求处理器映射(Handler Mapping)查找处理器(Handler)。
前端控制器调用处理器适配器(Handler Adapter)执行处理器(Handler)。
Handler 执行完成后返回ModelAndView对象。
处理器适配器将Handler执行结果ModelAndView对象返回给前端控制器。
前端控制器请求视图解析器(View Resolver)根据视图名解析视图(View)。
前端控制器相应用户。

以下是一个简单的Spring MVC控制器示例：




@Controller
public class HelloWorldController {
 
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public ModelAndView helloWorld() {
        String message = "Hello World, Spring MVC!";
        return new ModelAndView("hello", "message", message);
    }
}

在这个例子中，我们定义了一个简单的控制器HelloWorldController，它有一个处理/hello路径的GET请求的方法helloWorld()。该方法返回一个包含消息的ModelAndView对象，视图名为hello。

Spring MVC的核心就是：一个前端控制器DispatcherServlet，一个处理器映射HandlerMapping，一个处理器适配器HandlerAdapter，以及视图解析器ViewResolver。它们通过配置文件或注解相互关联，并且能够接收请求，分配处理给相应的处理器，并最终返回响应。

2024-09-05

报错解释：

当你访问swagger-ui/index.html时出现404错误，通常意味着请求的资源无法在服务器上找到。这可能是因为swagger-ui资源没有正确部署，或者请求的URL路径不正确。

解决方法：

确认是否已经将springdoc-openapi-starter-webmvc-ui添加到项目依赖中，并确保已经正确构建和启动了应用。
检查是否有正确的Spring Boot配置，确保SpringDoc能够自动配置。
确认是否使用了正确的URL路径访问swagger-ui。通常情况下，如果你使用的是springdoc-openapi-starter-webmvc-ui，并且没有修改默认配置，你应该可以通过http://<your-server-address>/swagger-ui/index.html访问到swagger-ui界面。
如果你使用了Spring Security，确保swagger-ui的路径没有被安全规则阻止。
如果以上都没问题，尝试清理并重新构建项目，有时候IDE或构建工具的缓存可能导致这类问题。

如果你遵循了以上步骤，但仍然遇到问题，可以查看项目的日志文件，寻找更具体的错误信息，或者在Stack Overflow等社区寻求帮助。

【SpringMVC】拦截器&JSR303的使用

2024-09-05




import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.validation.Valid;
 
@Controller
public class MyController {
 
    // 使用JSR303验证和Spring MVC的@Valid注解来处理验证
    @RequestMapping(value = "/submitData.do", method = RequestMethod.POST)
    public @ResponseBody String submitData(@Valid MyData data, BindingResult result) {
        if (result.hasErrors()) {
            // 如果有错误，返回错误信息
            return "Error: " + result.getFieldError().getDefaultMessage();
        }
        // 如果没有错误，处理数据
        return "Data processed: " + data.toString();
    }
}
 
// 需要验证的数据类
class MyData {
    @NotEmpty
    private String name;
 
    @Min(10)
    private int age;
 
    // getters and setters
}

这个例子中，我们定义了一个简单的Spring MVC控制器，其中包含一个处理POST请求的方法。我们使用了@Valid注解来触发JSR-303验证，并且传入了BindingResult来获取验证结果。如果验证失败，将返回错误信息；如果验证成功，将处理数据。这个例子展示了如何在Spring MVC中结合使用JSR303验证。

【SpringMvc】SpringMvc +MyBatis整理

2024-09-05

Spring MVC 与 MyBatis 整合通常涉及以下步骤：

添加依赖：在项目的pom.xml中添加Spring MVC、MyBatis和数据库连接的相关依赖。




<dependencies>
    <!-- Spring MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>你的Spring版本</version>
    </dependency>
    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>你的MyBatis版本</version>
    </dependency>
    <!-- 数据库驱动，例如MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>你的数据库驱动版本</version>
    </dependency>
    <!-- 其他依赖如数据库连接池、日志等 -->
</dependencies>

配置Spring MVC和MyBatis：在src/main/resources下创建或修改applicationContext.xml和mybatis-config.xml文件，以及数据库配置文件database.properties。

applicationContext.xml配置文件示例：




<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">
 
    <!-- 扫描Controller -->
    <context:component-scan base-package="你的controller包路径" />
 
    <!-- 配置MyBatis SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="configLocation" value="classpath:mybatis-config.xml" />
        <property name="dataSource" ref="dataSource" />
    </bean>
 
    <!-- 配置MyBatis Mapper接口扫描 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="你的mapper接口包路径" />
    </bean>
 
    <!-- 数据源配置，使用Spring的DataSource -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/数据库名?useSSL=false" />
        <property name="username" value="用户名" />

SpringBoot使用MockMVC单元测试Controller

2024-09-05




import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
 
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyControllerTest {
 
    private MockMvc mockMvc;
 
    @Autowired
    private WebApplicationContext webApplicationContext;
 
    @Before
    public void setup() {
        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
    }
 
    @Test
    public void testMyController() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/myEndpoint")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andDo(print());
    }
}

这段代码使用了Spring Boot的SpringRunner来运行测试，并利用MockMVC来模拟HTTP请求，测试了Controller中/myEndpoint的GET请求是否返回正确的响应（状态码200）。在实际的测试环境中，你需要替换MyControllerTest为你的测试类名，/myEndpoint为你的Controller端点，并根据你的Controller的实际行为调整测试逻辑。

2024-09-05

Spring是一个开源的Java/Java EE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用程序的方法。

Spring MVC是Spring的一个模块，提供了Web应用程序的Model-View-Controller实现。

Spring Boot是Spring的一个子项目，旨在简化Spring应用的初始搭建以及开发过程。

以下是Spring Boot的一个基本配置示例：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication // 标注这是一个Spring Boot应用
public class MySpringBootApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args); // 启动应用
    }
}

在application.properties或application.yml中配置属性：




# application.properties 示例
 
# 服务器端口
server.port=8080
 
# 数据库连接信息
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver




# application.yml 示例
 
server:
  port: 8080
 
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: myuser
    password: mypass
    driver-class-name: com.mysql.jdbc.Driver

这只是一个非常基本的示例，Spring Boot和Spring MVC可以做更多的配置和功能，如集成安全框架、使用JPA、定制数据库连接池、配置消息队列等。

【SpringBoot篇】分页查询 | 扩展SpringMvc的消息转换器

2024-09-05

在Spring Boot中，你可以通过扩展Spring MVC的消息转换器来实现分页查询功能。以下是一个简单的示例，演示如何扩展MappingJackson2HttpMessageConverter来支持自定义的分页信息转换。

首先，定义一个分页信息的类：




public class PaginationInfo {
    private int totalCount;
    private int totalPages;
    private int size;
    private int number;
 
    // 省略构造函数、getter和setter方法
}

然后，创建一个继承自MappingJackson2HttpMessageConverter的消息转换器：




import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.stereotype.Component;
 
@Component
public class CustomHttpMessageConverter extends MappingJackson2HttpMessageConverter {
    private final ObjectMapper objectMapper;
 
    public CustomHttpMessageConverter(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }
 
    @Override
    protected void writeInternal(Object object, Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        if (object instanceof PaginationInfo) {
            // 自定义PaginationInfo的JSON表示
            String json = objectMapper.writeValueAsString(object);
            outputMessage.getBody().write(json.getBytes(getCharset()));
        } else {
            super.writeInternal(object, type, outputMessage);
        }
    }
}

在上述代码中，我们覆盖了writeInternal方法，以便当返回的对象类型是PaginationInfo时，我们可以按照自定义的格式来序列化这个对象。

最后，确保你的CustomHttpMessageConverter被Spring容器管理，通常通过@Component注解实现。

这样，当你的控制器返回PaginationInfo对象时，它将被正确地序列化为JSON格式。




@RestController
public class MyController {
 
    @GetMapping("/items")
    public ResponseEntity<PaginationInfo> getItems(@RequestParam int page, @RequestParam int size) {
        // 分页查询逻辑...
        PaginationInfo paginationInfo = new PaginationInfo(totalCount, totalPages, size, page);
        return ResponseEntity.ok(paginationInfo);
    }
}

在这个例子中，PaginationInfo对象将被CustomHttpMessageConverter序列化为你所需的格式，而不是使用默认的Spring MVC序列化方式。

2024-09-05

Spring Boot是用于简化Spring应用的初始搭建以及开发过程的一个工具。它的目标是让你尽可能快地启动并运行一个生产级的Spring应用。

Spring Boot并不需要配置Tomcat，因为Spring Boot内置了Tomcat、Jetty、Undertow等容器，这些容器可以直接运行Spring Boot应用。Spring Boot通过自动配置帮助你完成这个过程，使得开发者不需要手动配置这些容器。

如果你想要使用Spring Boot开始一个新的项目，你只需要添加Spring Boot的起步依赖（starter dependencies）到你的构建配置文件中，然后通过一个主应用启动类（@SpringBootApplication注解的类）来启动应用。

Maven的pom.xml文件中的起步依赖可能看起来像这样：




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

对应的Gradle构建文件可能看起来像这样：




dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

然后你可以创建一个主应用类：




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

当你运行main方法时，Spring Boot会自动启动内嵌的Tomcat容器，并且你的应用就可以在指定的端口监听请求了。

2024-09-05




@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
 
    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Autowired
    private UserDetailsService userDetailsService;
 
    @Autowired
    private TokenStore tokenStore;
 
    @Autowired
    private JwtAccessTokenConverter jwtAccessTokenConverter;
 
    @Autowired
    private JwtTokenEnhancer jwtTokenEnhancer;
 
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
            .withClient("clientapp")
            .secret("123456")
            .authorizedGrantTypes("password", "refresh_token")
            .scopes("read", "write")
            .resourceIds("res1")
            .accessTokenValiditySeconds(1800)
            .refreshTokenValiditySeconds(3600);
    }
 
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
            .authenticationManager(authenticationManager)
            .userDetailsService(userDetailsService)
            .tokenStore(tokenStore)
            .accessTokenConverter(jwtAccessTokenConverter)
            .tokenEnhancer(jwtTokenEnhancer);
    }
}

这个代码实例展示了如何配置一个OAuth2授权服务器，使用JWT来进行访问令牌的签名和验证。代码中定义了客户端的配置和授权服务器端点的配置。其中TokenStore和JwtAccessTokenConverter是用于存储和转换JWT令牌的关键组件。JwtTokenEnhancer是一个自定义的令牌增强器，可以用于在JWT中添加额外的信息。

2024-09-05

Spring:

@Controller：标识一个类为控制器，用于接收用户的请求。

@Service：标识一个类为服务层类。

@Repository：标识一个类为数据访问层类，即DAO层。

@Component：泛指组件，当不好归类时使用。

@Autowired：自动按类型注入，如果有多个类型相同的bean，则按照名称注入。

@Qualifier：与@Autowired一起使用，指定要注入的bean的名称。

@Resource：默认按名称注入，如果找不到再按类型注入。

@Scope：指定bean的作用范围。

@RequestMapping：用于处理请求映射的注解，可以用于类或方法上。

@ResponseBody：将返回值放入response体内，通常用于返回JSON数据。

@RestController：组合注解，相当于@Controller和@ResponseBody的组合，表示该类中的所有方法返回的数据都会通过HttpMessageConverter序列化之后，写入到response体内，通常用于RESTful接口开发。

SpringMVC:

@Controller：标识一个类为控制器，用于接收用户的请求。

@RequestMapping：用于处理请求映射的注解，可以用于类或方法上。

@ResponseBody：将返回值放入response体内，通常用于返回JSON数据。

SpringBoot:

@SpringBootApplication：包含@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个注解，表示启动SpringBoot应用。

@EnableAutoConfiguration：启用SpringBoot自动配置。

@ComponentScan：指定SpringBoot扫描的包路径。

@ConfigurationProperties：指定配置属性。

@Value：注入配置文件中的值。

@ImportResource：导入Spring配置文件。

@ServletComponentScan：扫描Servlet、Filter和Listener组件。

@RestController：组合注解，相当于@Controller和@ResponseBody的组合，表示该类中的所有方法返回的数据都会通过HttpMessageConverter序列化之后，写入到response体内，通常用于RESTful接口开发。

SpringCloud:

@EnableEurekaServer：开启Eureka服务注册中心。

@EnableDiscoveryClient：开启服务发现。

@EnableCircuitBreaker：开启断路器功能。

@EnableFeignClients：开启Feign客户端。

@EnableZuulProxy：开启Zuul路由。

@HystrixCommand：指定方法为断路器保护的方法。

@EnableConfigServer：开启配置中心服务器。

@RefreshScope：刷新配置。

以上是常用的Spring、SpringMVC、SpringBoot和SpringCloud框架的一些注解，具体使用时需要根据实际情况选择合适的注解。