mapper Service servlet html之间的关系
时间: 2024-03-30 18:35:39 浏览: 14
在一个Web应用程序中,通常会使用多个组件来实现不同的功能。这些组件之间有着不同的职责,彼此协作来完成整个应用程序的工作。下面是这些组件的解释:
1. Mapper:Mapper是一个数据访问对象,它的主要作用是将Java对象映射到数据库中的表,并提供对数据库的访问和操作。Mapper通常使用MyBatis等持久化框架来实现。
2. Service:Service层是应用程序的业务逻辑层,它负责协调各个组件来处理业务逻辑,将请求转发给对应的Mapper对象来操作数据库,并将结果交给Controller来展示给用户。
3. Servlet:Servlet是Java Web应用程序中处理HTTP请求的组件。它负责接收来自客户端的请求,根据请求的URL和HTTP方法来调用相应的Service层方法来处理业务逻辑,并将处理结果返回给客户端。
4. HTML:HTML是用于构建Web页面的标记语言,它通过浏览器将页面展示给用户。HTML页面通常使用JavaScript来实现交互功能,例如通过Ajax调用Servlet来获取数据。
因此,这些组件之间的关系如下:客户端通过浏览器发送HTTP请求给Servlet,Servlet调用Service层方法来处理业务逻辑,并将结果传递给HTML页面,HTML页面通过JavaScript来展示数据和实现交互功能。同时,Service层调用Mapper来访问和操作数据库。
相关问题
mapper Service servlet html 的代码demo
下面是一个简单的代码示例,演示了这些组件之间的关系:
1. Mapper示例:
```java
public interface UserMapper {
User findUserById(int id);
void insertUser(User user);
void updateUser(User user);
void deleteUser(int id);
}
```
2. Service示例:
```java
public interface UserService {
User getUserById(int id);
void addUser(User user);
void updateUser(User user);
void deleteUser(int id);
}
```
```java
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public User getUserById(int id) {
return userMapper.findUserById(id);
}
@Override
public void addUser(User user) {
userMapper.insertUser(user);
}
@Override
public void updateUser(User user) {
userMapper.updateUser(user);
}
@Override
public void deleteUser(int id) {
userMapper.deleteUser(id);
}
}
```
3. Servlet示例:
```java
@WebServlet("/user/*")
public class UserServlet extends HttpServlet {
@Autowired
private UserService userService;
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 获取请求参数
int userId = Integer.parseInt(request.getParameter("id"));
// 调用Service层方法
User user = userService.getUserById(userId);
// 将结果转换为JSON格式并返回给客户端
response.setContentType("application/json;charset=utf-8");
response.getWriter().write(JSON.toJSONString(user));
}
}
```
4. HTML示例:
```html
<!DOCTYPE html>
<html>
<head>
<title>User Info</title>
<meta charset="utf-8">
<script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.min.js"></script>
</head>
<body>
<h1>User Info</h1>
<table>
<tr>
<th>ID</th>
<th>Name</th>
<th>Age</th>
<th>Gender</th>
</tr>
<tbody id="userList">
</tbody>
</table>
<script>
$(document).ready(function(){
// 发送Ajax请求获取用户信息
$.ajax({
url: "/user?id=1",
type: "GET",
dataType: "json",
success: function(data){
// 将结果展示到HTML页面上
var tr = $("<tr></tr>");
tr.append("<td>" + data.id + "</td>");
tr.append("<td>" + data.name + "</td>");
tr.append("<td>" + data.age + "</td>");
tr.append("<td>" + data.gender + "</td>");
$("#userList").append(tr);
},
error: function(){
alert("获取用户信息失败");
}
});
});
</script>
</body>
</html>
```
以上示例仅供参考,实际开发中可能需要根据具体需求进行修改。
用springboot springsecurity mybatisplus写一个登录以及退出的权限设置 含有domain层 controller层 service层以及mapper层
好的,下面是一个简单的示例代码:
1. 首先,创建一个User实体类,用于存储用户信息
```java
package com.example.demo.domain;
import lombok.Data;
@Data
public class User {
private Long id;
private String username;
private String password;
private String role;
}
```
2. 创建一个UserMapper接口,用于操作数据库
```java
package com.example.demo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.domain.User;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
```
3. 创建一个UserService接口及其实现类,用于处理业务逻辑
```java
package com.example.demo.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.example.demo.domain.User;
public interface UserService extends IService<User> {
User getUserByUsername(String username);
}
```
```java
package com.example.demo.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.domain.User;
import com.example.demo.mapper.UserMapper;
import com.example.demo.service.UserService;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Override
public User getUserByUsername(String username) {
return lambdaQuery().eq(User::getUsername, username).one();
}
}
```
4. 创建一个WebSecurityConfig类,用于配置Spring Security
```java
package com.example.demo.config;
import com.example.demo.handler.CustomAuthenticationFailureHandler;
import com.example.demo.handler.CustomAuthenticationSuccessHandler;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private UserService userService;
@Autowired
private CustomAuthenticationSuccessHandler customAuthenticationSuccessHandler;
@Autowired
private CustomAuthenticationFailureHandler customAuthenticationFailureHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/", "/login").permitAll()
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.successHandler(customAuthenticationSuccessHandler)
.failureHandler(customAuthenticationFailureHandler)
.permitAll()
.and()
.logout()
.logoutSuccessUrl("/")
.permitAll();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService()).passwordEncoder(passwordEncoder());
}
@Bean
public UserDetailsService userDetailsService() {
return username -> userService.getUserByUsername(username);
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
```
5. 创建一个CustomAuthenticationSuccessHandler类和一个CustomAuthenticationFailureHandler类,用于处理登录成功和登录失败的逻辑
```java
package com.example.demo.handler;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@Component
public class CustomAuthenticationSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
Authentication authentication) throws IOException, ServletException {
UserDetails userDetails = (UserDetails) authentication.getPrincipal();
request.getSession().setAttribute("username", userDetails.getUsername());
super.onAuthenticationSuccess(request, response, authentication);
}
}
```
```java
package com.example.demo.handler;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@Component
public class CustomAuthenticationFailureHandler extends SimpleUrlAuthenticationFailureHandler {
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
AuthenticationException exception) throws IOException, ServletException {
if (exception.getClass().isAssignableFrom(BadCredentialsException.class)) {
response.sendRedirect("/login?error=1");
} else {
super.onAuthenticationFailure(request, response, exception);
}
}
}
```
6. 创建一个UserController类,用于处理登录和退出的请求
```java
package com.example.demo.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
@Controller
public class UserController {
@GetMapping("/")
public String index() {
return "index";
}
@GetMapping("/login")
public String login() {
return "login";
}
@PostMapping("/logout")
public String logout() {
return "redirect:/";
}
}
```
7. 最后,创建一个login.html页面和一个index.html页面,用于展示登录和退出的效果
login.html:
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Login</title>
</head>
<body>
<h1>Login</h1>
<form action="/login" method="post">
<p><label>Username:</label> <input type="text" name="username"></p>
<p><label>Password:</label> <input type="password" name="password"></p>
<p><input type="submit" value="Login"></p>
</form>
<c:if test="${param.error != null}">
<p style="color: red">Incorrect username or password.</p>
</c:if>
</body>
</html>
```
index.html:
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Index</title>
</head>
<body>
<h1>Hello, ${sessionScope.username}!</h1>
<form action="/logout" method="post">
<p><input type="submit" value="Logout"></p>
</form>
</body>
</html>
```
以上就是一个简单的Spring Boot + Spring Security + MyBatis Plus的登录以及退出的权限设置示例代码。