小学期代码详解

字数：10.8k字 | 预计阅读时长：50分钟

本文主要介绍小学期代码的部分重要函数，源码地址：https://github.com/NagisaG/Museum-Final.git，项目网址：http://120.46.179.195:8888/guest/artifact/index，第一次尝试搭建网站，如有问题，请多多指教。

Controller

web配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package com.museum.Interceptor;

/**
 * 名称:CustomerInterceptor
 * 描述:
 *
 * @version 1.0
 * @author:Nagisa
 * @datetime:2023-06-27 18:35
 */
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.museum.pojo.Admin;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Date;

public class CustomerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        HttpSession session=request.getSession();
        System.out.println("拦截器取得session:"+session.getAttribute("username"));
        Object username=session.getAttribute("username");

            if (username != null) {
                //response.resetBuffer();
                return true;
            } else {
                response.sendRedirect(request.getContextPath() + "/checkLogin/tologin");
                //response.resetBuffer();
                return false;
            }
       /* HttpSession session=request.getSession();
        Object username=session.getAttribute("username");*/



    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        System.out.println("UserAuthInterceptor postHandle------------------------");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        System.out.println("Constomer afterCompletion");
        String logdir = request.getServletContext().getRealPath("log");//获取服务器记录日志log文件所存放的目录位置 -- tomcat下的真实路径+log目录
        //路径不存在就创建
        System.out.println(logdir);
        Path logdirPath = Paths.get(logdir);
        if(Files.notExists(logdirPath)){
            Files.createDirectories(logdirPath);
            System.out.println("创建目录:"+logdirPath);
        }
        //目录存在就将数据[字符]写入
        Path logfile = Paths.get(logdir,"userlog.log");//存放日志的路径+文件名
        BufferedWriter writer = new BufferedWriter(new FileWriter(logfile.toFile(),true));//logfile.toFile() paths转换为File类型 true以追加的方式写入
        Boolean isLoggedIn=(Boolean)request.getSession().getAttribute("isLogged");
        if(isLoggedIn!=null&isLoggedIn) {
            //获取登录用户信息
            //Users user = (Users)request.getSession().getAttribute("user");
            String username = (String) request.getSession().getAttribute("username");
            // String username = user.getUsername();
            //记录user登录时间，存入日志
            String ipAddress = request.getRemoteAddr();
            // 其他相关信息，如浏览器、操作系统等
            String userAgent = request.getHeader("User-Agent");
            String message = username + " 登录时间：" + new Date() + "IP地址：" + ipAddress + "用户代理：" + userAgent;
            writer.write(message + "\r\n");
            writer.flush();
            writer.close();
        }
    }
}

这段代码是一个Java类，名为WebMvcConfig，它实现了WebMvcConfigurer接口。这个类主要用于配置Spring MVC框架的一些行为和功能。下面是它的功能介绍：

  1. 拦截器配置：
    通过重写addInterceptors方法，将一个名为CustomerInterceptor的拦截器添加到拦截器注册表中。
    使用.addPathPatterns(“/“)指定了需要拦截的路径模式，即对所有请求进行拦截。
    使用.excludePathPatterns排除了一些不需要拦截的路径，包括
    /checkLogin/tologin、/checkLogin/dopost、/museum/findall、/static/、/css/、/images/和/js/**。

  2. 静态资源处理器配置：
    通过重写addResourceHandlers方法，配置了静态资源的处理器。
    使用.addResourceHandler(“/static/**”)指定了对以/static/开头的请求进行处理。
    使用.addResourceLocations(“classpath:/static/“)指定了静态资源所在的路径，这里是在classpath下的/static/目录。

  3. 跨域请求配置：
    通过重写addCorsMappings方法，配置了跨域请求的设置。
    使用.addMapping(“/**”)指定了允许跨域请求的路径模式，这里是对所有请求都进行跨域配置。
    使用.allowedOrigins(“http:localhost:8888”)指定了允许跨域请求的来源，这里是允许来自http://localhost:8888的请求。
    总体来说，这段代码的功能是配置拦截器、静态资源处理器和跨域请求设置，以满足具体的需求，例如进行登录验证、处理静态资源和允许特定来源的跨域请求。

管理员控制器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
package com.museum.controller;

import com.museum.pojo.Admin;
import com.museum.service.AdminService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * 名称:AdminController
 * 描述:管理员的控制器
 *
 * @version 1.0
 * @author:Nagisa
 * @datetime:2023-06-26 16:45
 */
@Controller
@RequestMapping("/admin")
public class AdminController {
    @Autowired(required = false)
    private AdminService adminService;
   /* @RequestMapping("/tologin")
    public String tologin(){
        return "adminlogin";
    }*/

    public Admin getAdminWithPermissin(@RequestParam(name="username") String username){
        Admin admin=adminService.getAdminWithPermissin(username);
        System.out.println(admin);
        return admin;
    }
    public boolean judgePermission(HttpServletRequest request){
        String username=(String) request.getSession().getAttribute("username");
        String permission=adminService.getAdminWithPermissin(username).getPermission();
        return permission.equals("一级");
    }
    @RequestMapping("/findall")
    public String findAllAdmins(Model model, HttpServletRequest request) {
        /*HttpSession session = request.getSession();
        String username = (String) session.getAttribute("username");
        String permission=adminService.getAdminWithPermissin(username).getPermission();
        System.out.println("权限为："+permission);*/
        if (judgePermission(request)) {
            List<Admin> adminList = adminService.findAllAdmins();
            for (Admin admin : adminList)
                System.out.println(admin.getUsername());
            model.addAttribute("alist", adminList);
            return "AdminIndex";
        }
        else {
            model.addAttribute("msg","权限不足");
            return "public/false";
        }
    }
    @RequestMapping("/toinsert")
    public String toInsert(){
        return "Admin/InsertAdmin";
    }
    @RequestMapping("/insert")
    public String insertAdmin(Admin admin,Model model,HttpServletRequest request) {
        if(judgePermission(request)) {
            System.out.println("新增管理员信息:" + admin);
            int i = adminService.insertAdmin(admin);
            if (i > 0) {
                List<Admin> adminList = adminService.findAllAdmins();
                model.addAttribute("alist", adminList);
                model.addAttribute("msg", "添加成功");
                return "AdminIndex";
            } else {
                model.addAttribute("msg","新增管理员信息失败");
                return "public/false";
            }
        }else{
            model.addAttribute("msg","权限不足");
            return "public/false";
        }
    }

    @RequestMapping("/toupdate/{username}")
    public String toupdate(@PathVariable("username") String username,Model model,HttpServletRequest request){
        if(judgePermission(request)) {
            List<Admin> adminList = adminService.findAdminByUsername(username);
            Admin admin = adminList.get(0);
            model.addAttribute("admin",admin);
            return "Admin/UpdateAdmin";//返回的是admin文件夹下的updateadmin.html文件
        }
        else {
            model.addAttribute("msg","权限不足");
            return "public/false";
        }
    }

    @RequestMapping("/update")
    public String updateAdmin(Admin admin,Model model,HttpServletRequest request){
        if(judgePermission(request)){
            int i=adminService.updateAdmin(admin);
            if (i > 0) {
                // List<Museum> museumList1 = museumService.findAllMuseums();
                List<Admin> adminList1=adminService.findAllAdmins();
                model.addAttribute("alist", adminList1);
                model.addAttribute("msg", "更新成功");
                return "AdminIndex";//返回Admin文件夹下adminlist.html文件
            } else {
                model.addAttribute("msg","更新失败");
                return "public/false";
            }
        }
        else {
            model.addAttribute("msg","权限不足");
            return "public/false";
        }
    }

    @RequestMapping("/findbyname")
    public String findAdminByUsername(@RequestParam(value="searchStr") String searchStr,Model model,HttpServletRequest request){
        if (judgePermission(request)){
            List<Admin> adminList = adminService.findAdminByUsername(searchStr);
            if (adminList.size() > 0) {
                model.addAttribute("alist", adminList);
                model.addAttribute("msg", "查询成功");
                return "AdminIndex";
            } else {
                model.addAttribute("msg","查询失败");
                return "public/false";
            }
        }
        else {
            model.addAttribute("msg","权限不足");
            return "public/false";
        }
    }

    // List<Admin> findAdminByPermission(String username);//根据权限查询管理员
    @RequestMapping("/findbypermission")
    public String findAdminByPermission(@RequestParam(value = "permission") String permission,Model model,HttpServletRequest request){
        if (judgePermission(request)){
            List<Admin> adminList = adminService.findAdminByPermission(permission);
            if (adminList.size() > 0) {
                model.addAttribute("alist", adminList);
                model.addAttribute("msg", "查询成功");
                return "AdminIndex";
            } else {
                model.addAttribute("msg","查询失败");
                return "public/false";
            }
        }
        else {
            model.addAttribute("msg","权限不足");
            return "public/false";
        }
    }

    @RequestMapping("/deletebyname/{username}")
    public String deleteAdminByName(@PathVariable("username") String username,Model model,HttpServletRequest request){
        if(judgePermission(request)){
            int i=adminService.deleteAdminByName(username);
            if(i>0){
                List<Admin> adminList=adminService.findAllAdmins();
                model.addAttribute("alist",adminList);
                model.addAttribute("msg","删除管理员信息成功");
                return "AdminIndex";
            }
            else {
                model.addAttribute("msg","未找到指定用户");
                return "public/false";
            }
        } else {
            model.addAttribute("msg","权限不足");
            return "public/false";
        }
    }

    @RequestMapping("/delete")
    public String deleteAdmins(String[] usernames,Model model,HttpServletRequest request){
        if(judgePermission(request)){
            if(usernames!=null){
                int i=adminService.deleteAdmins(usernames);
                if(i>0){
                    List<Admin> adminList=adminService.findAllAdmins();
                    model.addAttribute("alist",adminList);
                    model.addAttribute("msg","删除管理员信息成功");
                    return "AdminIndex";
                }
                else {
                    model.addAttribute("msg","用户不存");
                    return "public/false";
                }
            }
            else {
                model.addAttribute("msg","未选择用户");
                return "public/false";
            }
        }
        else {
            model.addAttribute("msg","权限不足");
            return "public/false";
        }
    }
}

控制器类AdminController中定义的各个方法的功能如下：

  1. getAdminWithPermissin(String username): 根据用户名获取具有权限的管理员对象，并返回该对象。内部通过调用adminService.getAdminWithPermissin(username)实现。
  2. judgePermission(HttpServletRequest request): 判断当前用户是否具有足够的权限。通过从会话中获取用户名，并获取该用户的权限进行比较。内部通过调用adminService.getAdminWithPermissin(username)获取管理员对象，并比较其权限是否为”一级”。
  3. findAllAdmins(Model model, HttpServletRequest request): 获取所有管理员的列表并返回视图。如果当前用户具有足够的权限，则调用adminService.findAllAdmins()获取管理员列表，并将列表添加到Model中，返回视图”adminindex”。否则，将错误消息添加到Model中，返回视图”public/false”。
  4. insertAdmin(Admin admin, Model model, HttpServletRequest request): 插入新的管理员信息。如果当前用户具有足够的权限，则调用adminService.insertAdmin(admin)将新管理员插入数据库。如果插入成功，获取所有管理员列表并添加到Model中，返回视图”admin/adminlist”。如果权限不足，将错误消息添加到Model中，返回视图”public/false”。
  5. toupdate(String username, Model model, HttpServletRequest request): 根据用户名获取指定管理员信息，并返回视图以便更新管理员信息。如果当前用户具有足够的权限，则通过调用adminService.findAdminByUsername(username)获取指定用户名的管理员对象，将该对象添加到Model中，返回视图”admin/updateadmin”。如果权限不足，将错误消息添加到Model中，返回视图”public/false”。
  6. updateAdmin(Admin admin, Model model, HttpServletRequest request): 更新管理员信息。如果当前用户具有足够的权限，则调用adminService.updateAdmin(admin)更新管理员信息。如果更新成功，获取所有管理员列表并添加到Model中，返回视图”adminindex”。如果更新失败，将错误消息添加到Model中，返回视图”public/false”。
  7. findAdminByUsername(String searchStr, Model model, HttpServletRequest request): 根据用户名查询管理员信息。如果当前用户具有足够的权限，则调用adminService.findAdminByUsername(searchStr)根据用户名搜索管理员，并将结果添加到Model中，返回视图”admin/adminlist”。如果没有找到匹配的结果，将错误消息添加到Model中，返回视图”public/false”。
  8. findAdminByPermission(String permission, Model model, HttpServletRequest request): 根据权限查询管理员信息。如果当前用户具有足够的权限，则调用adminService.findAdminByPermission(permission)根据权限搜索管理员，并将结果添加到Model中，返回视图”admin/adminlist”。如果没有找到匹配的结果，将错误消息添加到Model中，返回视图”public/false”。
  9. deleteAdminByName(String username, Model model, HttpServletRequest request): 根据用户名删除管理员信息。如果当前用户具有足够的权限，则调用adminService.deleteAdminByName(username)根据用户名删除管理员。如果删除成功，获取所有管理员列表并添加到Model中，返回视图”admin/adminlist”。如果没有找到匹配的结果，将错误消息添加到Model中，返回视图”public/false”。

10.deleteAdmins(String[] usernames, Model model, HttpServletRequest request): 根据用户名数组批量删除管理员信息。如果当前用户具有足够的权限，则调用adminService.deleteAdmins(usernames)根据用户名数组删除管理员。如果删除成功，获取所有管理员列表并添加到Model中，返回视图”admin/adminlist”。如果没有找到匹配的结果，将错误消息添加到Model中，返回视图”public/false”。

这些方法用于处理具体的请求，包括获取管理员信息、插入新管理员、更新管理员信息、删除管理员信息、查询管理员等操作，并根据当前用户的权限进行验证和处理。

管理员管理文物

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
package com.museum.controller;

import com.museum.pojo.Artifact;
import com.museum.pojo.ExcelParser;

import com.museum.service.ArtifactAdminService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.util.List;

/**
 * 名称ArtifactController
 * 描述
 *
 * @version 1.0
 * @author:DuanMM
 * @datatime:2023-06-27 12:13
 */
@Controller
@RequestMapping("/artifact")
public class ArtifactAdminController {
    @Autowired(required = false)
    private ArtifactAdminService artifactAdminService;

    //跳转到系统首页
    @RequestMapping("/index")
    public String toIndex(){
        return "index";
    }

    //跳转到添加文物页面
    @RequestMapping("/toinsert")
    public String toInsert(){
        return "Artifact/InsertArtifact";
    }

    //添加文物信息
    @RequestMapping("/insert")
    public String insertArtifact(Artifact artifact, Model model){
        System.out.println("新增文物信息："+artifact);
        int i = artifactAdminService.insertArtifact(artifact);
        if(i > 0){
            List<Artifact> artifactlist = artifactAdminService.findAllArtifacts();
            model.addAttribute("alist",artifactlist);
            model.addAttribute("msg","添加文物信息成功");
            return "ArtifactIndex";
        }
        else{
            return "public/false";
        }
    }

    //查询全部文物
    @RequestMapping("/findall")
    public String findAllArtifacts(Model model){
        List<Artifact> artifactlist = artifactAdminService.findAllArtifacts();
        for(Artifact artifact:artifactlist)
            System.out.println(artifact.getArtname()+" " +artifact.getDynasty()+" "+artifact.getImage()+" "+artifact.getCollected());
        model.addAttribute("alist",artifactlist);
        return "ArtifactIndex";
    }

    //模糊查询
    @RequestMapping("/findbystr")
    public String findArtifactByStr(@RequestParam(value = "searchStr") String searchStr, Model model){
        List<Artifact> artifactlist= artifactAdminService.findArtifactByStr(searchStr);
        model.addAttribute("alist",artifactlist);
        return "ArtifactIndex";
    }

    //根据名称准确查找
    @RequestMapping("/findbyname")
    public Artifact findArtifactByName(@RequestParam(name="name") String name){
        Artifact artifact = artifactAdminService.findArtifactByName(name);
        System.out.println(artifact);
        return artifact;
    }

    //跳转到文物修改页面
    @RequestMapping("/toupdate/{artname}")
    public String toupdate(@PathVariable("artname") String name, Model model){
        Artifact artifact = artifactAdminService.findArtifactByName(name);
        model.addAttribute("artifact",artifact);
        return "Artifact/UpdateArtifact";
    }

    //修改文物信息
    @RequestMapping("/update")
    public String updateArtifact(Artifact artifact, Model model){
        int i = artifactAdminService.updateArtifact(artifact);
        if(i > 0){
            List<Artifact> artifactlist = artifactAdminService.findAllArtifacts();
            model.addAttribute("alist",artifactlist);
            model.addAttribute("msg","修改文物信息成功");
            return "ArtifactIndex";
        }
        else{
            return "public/false";
        }
    }

    //根据名称删除
    @RequestMapping("/deletebyname/{artname}")
    public String deleteArtifactByName(@PathVariable("artname") String name, Model model){
        int i = artifactAdminService.deleteArtifactByName(name);
        if(i > 0){
            List<Artifact> artifactlist = artifactAdminService.findAllArtifacts();
            model.addAttribute("alist",artifactlist);
            model.addAttribute("msg","删除文物信息成功");
            return "ArtifactIndex";
        }
        else{
            return "public/false";
        }
    }

    //批量删除
    @RequestMapping("/delete")
    public String deleteArtifacts(String[] names,Model model){
        if(names != null && names.length > 0){
            int i = artifactAdminService.deleteArtifacts(names);
            if(i > 0){
                List<Artifact> artifactlist = artifactAdminService.findAllArtifacts();
                model.addAttribute("alist",artifactlist);
                model.addAttribute("msg","批量删除文物成功");
                return "ArtifactIndex";
            }
            else{
                return "public/false";
            }
        }
        else{
            model.addAttribute("msg","未选择任何文物信息，无法删除");
            return "public/false";
        }
    }

    //上传
    @ResponseBody
    @RequestMapping("/upload")
    public String uploadArtifactExcel(@RequestParam("file") MultipartFile file) {
        // 检查文件是否为空
        if (file.isEmpty()) {
            return "请选择要上传的文件";
        }
        try {
            // 示例：打印文件名和大小
            String fileName = file.getOriginalFilename();
            long fileSize = file.getSize();
            System.out.println("上传的文件名：" + fileName);
            System.out.println("文件大小：" + fileSize + " bytes");

            // 检查文件类型
            if (!fileName.toLowerCase().endsWith(".xlsx")) {
                return "请上传 *.xlsx 文件";
            }

            // 将MultipartFile对象转换为InputStream
            InputStream inputStream = file.getInputStream();

            // 创建ExcelParser对象并解析Excel文件
            ExcelParser parser = new ExcelParser();
            List<Artifact> artifacts = parser.parseExcel(inputStream);

            // 处理解析后的文物对象列表
            for (Artifact artifact : artifacts) {
                Artifact existArtifact = artifactAdminService.findArtifactByName(artifact.getArtname());
                if (existArtifact != null) {
                    artifact.setArtname(artifact.getArtname());
                    artifactAdminService.updateArtifact(artifact);
                } else {
                    artifactAdminService.insertArtifact(artifact);
                }
            }
            return "artifactindex";
        } catch (Exception e) {
            e.printStackTrace();
            return "public/false";
        }
    }
}


这是一个名为ArtifactAdminController的控制器类，处理与文物管理相关的请求。下面是每个函数的功能：

  1. toIndex(): 跳转到系统首页的请求处理函数，返回视图”index”。
  2. toInsert(): 跳转到添加文物页面的请求处理函数，返回视图”artifact/insertartifact”。
  3. insertArtifact(Artifact artifact, Model model): 处理添加文物信息的请求。调用artifactAdminService.insertArtifact(artifact)方法将文物信息插入数据库。如果插入成功，获取所有文物列表并添加到Model中，返回视图”artifact/artifact”。如果插入失败，返回视图”public/false”。
  4. findAllArtifacts(Model model): 查询所有文物的请求处理函数。调用artifactAdminService.findAllArtifacts()方法获取所有文物列表，并将列表添加到Model中，返回视图”artifact/artifactlist”。
  5. findArtifactByStr(String searchStr, Model model): 处理根据关键词模糊查询文物的请求。调用artifactAdminService.findArtifactByStr(searchStr)方法根据关键词搜索文物，并将结果添加到Model中，返回视图”artifact/artifactlist”。
  6. findArtifactByName(String name): 处理根据文物名称准确查找文物的请求。调用artifactAdminService.findArtifactByName(name)方法根据名称查找文物，并返回查找到的文物对象。
  7. toupdate(String name, Model model): 跳转到文物修改页面的请求处理函数。调用artifactAdminService.findArtifactByName(name)方法根据名称获取指定文物对象，将该对象添加到Model中，返回视图”artifact/updateartifact”。
  8. updateArtifact(Artifact artifact, Model model): 处理修改文物信息的请求。调用artifactAdminService.updateArtifact(artifact)方法更新文物信息。如果更新成功，获取所有文物列表并添加到Model中，返回视图”artifact/artifactlist”。如果更新失败，返回视图”public/false”。
  9. deleteArtifactByName(String name, Model model): 处理根据文物名称删除文物的请求。调用artifactAdminService.deleteArtifactByName(name)方法根据名称删除文物。如果删除成功，获取所有文物列表并添加到Model中，返回视图”artifact/artifactlist”。如果删除失败，返回视图”public/false”。

10.deleteArtifacts(String[] names, Model model): 处理批量删除文物的请求。调用artifactAdminService.deleteArtifacts(names)方法根据名称数组批量删除文物。如果删除成功，获取所有文物列表并添加到Model中，返回视图”artifact/artifactlist”。如果删除失败，返回视图”public/false”。

11.uploadArtifactExcel(MultipartFile file): 处理上传文物Excel文件的请求。检查文件是否为空，然后检查文件类型是否为.xlsx后缀。将MultipartFile对象转换为InputStream，并创建ExcelParser对象。调用ExcelParser对象的parseExcel()方法解析Excel文件，并将解析后的文物列表保存到数据库。如果文物已存在，则更新文物信息；如果文物不存在，则插入新的文物信息。最后返回相应的上传结果信息。

登录认证

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package com.museum.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * 名称:LoggedController
 * 描述:
 *
 * @version 1.0
 * @author:Nagisa
 * @datetime:2023-06-29 16:38
 */
@Controller
//@SessionAttributes("LoggedIn")
//@WebServlet("/mainPage")
@RequestMapping("/user")
public class LoggedController extends HttpServlet {

    //@GetMapping("/dashboard")
    @Autowired(required = false)
    private AdminController adminController;
    @RequestMapping("/adminindex")
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException{
        response.setContentType("text/html;charset=utf-8");
        HttpSession session=request.getSession();
        System.out.println("Logged页面："+session.getAttribute("username"));
        Object username=session.getAttribute("username");
        //PrintWriter writer=response.getWriter();

            if (username != null) {
                //writer.write("<h1>用户："+username+" 登录成功</h1>");
                response.sendRedirect(request.getContextPath() + "/museum/index");
            } else {
                response.sendRedirect(request.getContextPath() + "/checkLogin/tologin");
            }
        /*finally {
            if(response!=null)
            {
                response.getWriter().flush();
                response.getWriter().close();
            }
        }*/

    }
    @RequestMapping("/dopost")
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
        //response.reset();
    }


}
  1. doGet(HttpServletRequest request, HttpServletResponse response): 该方法处理GET请求，用于用户访问”/user/adminindex”路径时执行的逻辑。它首先获取当前会话（session）中的”username”属性，如果该属性存在（即用户已登录），则重定向到”/adminindex”路径；否则，重定向到”/checkLogin/tologin”路径，即跳转到登录页面。
  2. doPost(HttpServletRequest request, HttpServletResponse response): 该方法处理POST请求，调用了doGet()方法，实现了对POST请求的统一处理，即与GET请求相同的逻辑。

总体来说，这两个方法主要用于用户登录状态的验证和跳转逻辑。当用户访问”/user/adminindex”路径时，会根据用户是否已登录来进行相应的页面跳转。如果已登录，则重定向到管理员首页”/adminindex”；如果未登录，则重定向到登录页面”/checkLogin/tologin”。

登录判断界面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package com.museum.controller;

//import com.museum.Listener.UserListener;
import com.museum.pojo.Admin;
import com.museum.service.ALogInService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

/**
 * 名称:LoginController
 * 描述:
 *
 * @version 1.0
 * @author:Nagisa
 * @datetime:2023-06-29 11:27
 */


@Controller
@RequestMapping("checkLogin")
public class LoginController extends HttpServlet {

    @Autowired(required = false)
    private ALogInService aLogInService;
    @RequestMapping("/tologin")
    public String tologin(){
        return "Login";
    }
    @RequestMapping("/doget")
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException{
        String username=request.getParameter("username");
        String password=request.getParameter("password");
        List<Admin> adminList=aLogInService.logInSearch(username,password);

            if (adminList.size() != 0) {
                HttpSession session = request.getSession();
                System.out.println(session.getAttribute("username"));
                session.setMaxInactiveInterval(60 * 60 * 24);
                session.setAttribute("username", username);
                response.sendRedirect(request.getContextPath() + "/index");
                //return "index";
            } else {
                response.setContentType("text/html;charset=utf-8");
                PrintWriter writer = response.getWriter();
                writer.write("<h1>账号或密码错误<h1>");
                writer.write("<h3><a href='" + request.getContextPath() + "/tologin'>点击重新登录</a></h3>");
                //return "login";
            }
        /*finally {
            if(response!=null)
            {
                response.getWriter().flush();
                response.getWriter().close();
            }
        }*/
    }

   @RequestMapping("/dopost")
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
       request.getSession().setAttribute("isLogged", true);
        //response.reset();
    }

}

  1. tologin(): 该方法返回一个字符串”login”，用于指定跳转到登录页面。当用户访问”/checkLogin/tologin”路径时，会调用该方法返回登录页面的视图。

  2. doGet(HttpServletRequest request, HttpServletResponse response): 该方法处理GET请求，用于用户提交登录表单时执行的逻辑。它首先从请求参数中获取用户名(username)和密码(password)，然后调用aLogInService.logInSearch(username, password)方法进行登录验证。

    • 如果登录验证成功，即adminList列表的大小不为0，表示用户名和密码正确，将用户名存储到会话(session)中的”username”属性，并设置会话的最大非活动时间为1天(60 * 60 * 24秒)。最后，重定向到”/user/adminindex”路径，即跳转到管理员首页。
    • 如果登录验证失败，即adminList列表的大小为0，表示用户名或密码错误，设置响应内容的编码格式为UTF-8，然后通过response.getWriter()方法获取PrintWriter对象，输出错误信息和重新登录的链接。最后，用户将看到错误提示并可以点击链接返回登录页面。

  4. doPost(HttpServletRequest request, HttpServletResponse response): 该方法处理POST请求，调用了doGet()方法，实现了对POST请求的统一处理，即与GET请求相同的逻辑。此外，还设置了会话(session)中的”isLogged”属性为true，表示用户已登录。

总体来说，这个类的主要功能是处理用户的登录请求。当用户访问”/checkLogin/tologin”路径时，会返回登录页面。当用户提交登录表单时，会进行用户名和密码的验证。验证成功后，将用户名存储到会话中并重定向到管理员首页；验证失败后，返回错误提示并可以重新登录。同时，POST请求的处理与GET请求相同，并设置会话中的”isLogged”属性为true，表示用户已登录。

管理员博物馆控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
package com.museum.controller;

import com.museum.pojo.Museum;
import com.museum.service.MuseumService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;

/**
 * 名称:MuseumController
 * 描述:Museum的控制类
 *
 * @version 1.0
 * @author:Nagisa
 * @datetime:2023-06-25 17:26
 */
@Controller
@RequestMapping("/museum")
public class MuseumController {
    @Autowired(required = false)
    private MuseumService museumService;
    //跳转到系统首页
    @RequestMapping("/index")
    public String toIndex(){
        return "index";
    }

    @RequestMapping("/findall")
    public String findAllMuseums(Model model)
    {
        List<Museum> museumList=museumService.findAllMuseums();
        for(Museum museum:museumList)
            System.out.println(museum.getMuseum_name());
        model.addAttribute("mlist",museumList);
        return "MuseumIndex";
    }

    @RequestMapping("/findbyprovince")
    public String findMuseumByProvince(@RequestParam(value="province") String province, Model model)
    {
        // List<Museum> museumList=museumService.findAllMuseums();
        List<Museum> museumList=museumService.findMuseumByProvince(province);
        if(museumList.size()>0)
        {
            model.addAttribute("mlist",museumList);
            model.addAttribute("msg","查询成功");
            return "MuseumIndex";
        }
        else{
            return "public/false";
        }
    }
    @RequestMapping("/findbyname")
    public String findMuseumByName(@RequestParam(value="museum_name") String museum_name, Model model)
    {
        // List<Museum> museumList=museumService.findAllMuseums();
        List<Museum> museumList=museumService.findMuseumByName(museum_name);
        if(museumList.size()>0)
        {
            model.addAttribute("mlist",museumList);
            model.addAttribute("msg","查询成功");
            return "MuseumIndex";
        }
        else{
            return "public/false";
        }
    }

    @RequestMapping("/findbylevel")
    public String findMuseumByLevel(@RequestParam(value="level") String level, Model model) {
        // List<Museum> museumList=museumService.findAllMuseums();
        List<Museum> museumList = museumService.findMuseumByLevel(level);
        if (museumList.size() > 0) {
            model.addAttribute("mlist", museumList);
            model.addAttribute("msg", "查询成功");
            return "MuseumIndex";
        } else {
            return "public/false";
        }
    }

    @RequestMapping("/findbytype")
    public String findMuseumByType(@RequestParam(value="type") String type, Model model) {
        // List<Museum> museumList=museumService.findAllMuseums();
        List<Museum> museumList = museumService.findMuseumByType(type);
        if (museumList.size() > 0) {
            model.addAttribute("mlist", museumList);
            model.addAttribute("msg", "查询成功");
            return "MuseumIndex";
        } else {
            return "public/false";}
    }
    @RequestMapping("/findbyisfree")
    public String findMuseumByIsfree(@RequestParam(value="isfree") String isfree, Model model) {
        // List<Museum> museumList=museumService.findAllMuseums();
        List<Museum> museumList = museumService.findMuseumByIsfree(isfree);
        if (museumList.size() > 0) {
            model.addAttribute("mlist", museumList);
            model.addAttribute("msg", "查询成功");
            return "MuseumIndex";
        } else {
            return "public/false";}
    }

    @RequestMapping("/findbystr")
    public String findMuseumByStr(@RequestParam(value="searchStr") String searchStr, Model model) {
        // List<Museum> museumList=museumService.findAllMuseums();
        List<Museum> museumList = museumService.findMuseumByStr(searchStr);
        if (museumList.size() > 0) {
            model.addAttribute("mlist", museumList);
            model.addAttribute("msg", "查询成功");
            return "MuseumIndex";
        } else {
            return "public/false";}
    }

    @RequestMapping("/deletebyname/{museum_name}")
    public String deleteMuseumByName(@PathVariable("museum_name") String museum_name,Model model){
        int i=museumService.deleteMuseumByName(museum_name);
        if(i>0){
            List<Museum> museumList=museumService.findAllMuseums();
            model.addAttribute("mlist",museumList);
            model.addAttribute("msg","删除博物馆信息成功");
            return "MuseumIndex";
        }
        else {
            return "public/false";
        }
    }
    @RequestMapping("/toupdate/{museum_name}")
    public String toupdate(@PathVariable("museum_name")String museum_name,Model model){
        List<Museum> museumList=museumService.findMuseumByName(museum_name);
        model.addAttribute("museum",museumList.get(0));
        return "Museum/UpdateMuseum";
    }
    @RequestMapping("/update")
    public String updateMuseum(Museum museum,Model model){
        int i=museumService.updateMuseum(museum);
        if(i>0){
            List<Museum> museumList1=museumService.findAllMuseums();
            model.addAttribute("mlist",museumList1);
            model.addAttribute("msg","更新成功");
            return "MuseumIndex";
        }else{
            return "public/false";
        }
    }
    @RequestMapping("/toinsert")
    public String toInsert(){
        return "Museum/InsertMuseum";
    }
    @RequestMapping("/insert")
    public String insertMuseum(Museum museum,Model model){
        System.out.println("新增博物馆信息："+museum);
        int i=museumService.insertMuseum(museum);
        if(i>0){
            List<Museum> museumList=museumService.findAllMuseums();
            model.addAttribute("mlsist",museumList);
            model.addAttribute("msg","添加博物馆信息成功");
            return "MuseumIndex";
        }else{
            return "public/false";
        }
    }

}

这个类是一个控制器(Controller)，主要用于处理与博物馆相关的请求。以下是每个方法的功能：

  1. toIndex(): 跳转到系统首页，返回字符串”index”，用于指定跳转到名为”index”的视图页面。
  2. findAllMuseums(Model model): 查询所有博物馆信息，并将结果存储在Model对象中。通过调用museumService.findAllMuseums()方法获取博物馆列表，并将列表添加到Model对象的属性”mlist”中。最后，返回字符串”museum/museumlist”，用于指定跳转到名为”museum/museumlist”的视图页面。
  3. findMuseumByProvince(String province, Model model): 根据省份查询博物馆信息。通过调用museumService.findMuseumByProvince(province)方法获取符合条件的博物馆列表。如果列表的大小大于0，表示查询成功，将列表和一个”msg”属性添加到Model对象中，并返回字符串”museum/museumlist”，用于指定跳转到名为”museum/museumlist”的视图页面。如果列表的大小为0，表示查询失败，返回字符串”public/false”。
  4. findMuseumByName(String museum_name, Model model): 根据博物馆名称查询博物馆信息。通过调用museumService.findMuseumByName(museum_name)方法获取符合条件的博物馆列表。如果列表的大小大于0，表示查询成功，将列表和一个”msg”属性添加到Model对象中，并返回字符串”museum/museumlist”，用于指定跳转到名为”museum/museumlist”的视图页面。如果列表的大小为0，表示查询失败，返回字符串”public/false”。
  5. findMuseumByLevel(String level, Model model): 根据博物馆级别查询博物馆信息。通过调用museumService.findMuseumByLevel(level)方法获取符合条件的博物馆列表。如果列表的大小大于0，表示查询成功，将列表和一个”msg”属性添加到Model对象中，并返回字符串”museum/museumlist”，用于指定跳转到名为”museum/museumlist”的视图页面。如果列表的大小为0，表示查询失败，返回字符串”public/false”。
  6. findMuseumByType(String type, Model model): 根据博物馆类型查询博物馆信息。通过调用museumService.findMuseumByType(type)方法获取符合条件的博物馆列表。如果列表的大小大于0，表示查询成功，将列表和一个”msg”属性添加到Model对象中，并返回字符串”museum/museumlist”，用于指定跳转到名为”museum/museumlist”的视图页面。如果列表的大小为0，表示查询失败，返回字符串”public/false”。
  7. findMuseumByIsfree(String isfree, Model model): 根据是否免费查询博物馆信息。通过调用museumService.findMuseumByIsfree(isfree)方法获取符合条件的博物馆列表。如果列表的大小大于0，表示查询成功，将列表和一个”msg”属性添加到Model对象中，并返回字符串”museum/museumlist”，用于指定跳转到名为”museum/museumlist”的视图页面。如果列表的大小为0，表示查询失败，返回字符串”public/false”。
  8. findMuseumByStr(String searchStr, Model model): 根据关键词查询博物馆信息。通过调用museumService.findMuseumByStr(searchStr)方法获取符合条件的博物馆列表。如果列表的大小大于0，表示查询成功，将列表和一个”msg”属性添加到Model对象中，并返回字符串”museum/museumlist”，用于指定跳转到名为”museum/museumlist”的视图页面。如果列表的大小为0，表示查询失败，返回字符串”public/false”。
  9. deleteMuseumByName(String museum_name, Model model): 根据博物馆名称删除博物馆信息。通过调用museumService.deleteMuseumByName(museum_name)方法删除对应的博物馆信息。如果删除成功，重新查询所有博物馆信息并添加到Model对象中，然后返回字符串”Museum/museumlist”，用于指定跳转到名为”Museum/museumlist”的视图页面。如果删除失败，返回字符串”public/false”。
  10. toupdate(String username, Model model): 根据博物馆名称跳转到更新博物馆信息的页面。通过调用museumService.findMuseumByName(username)方法获取对应的博物馆信息，然后将第一个博物馆对象添加到Model对象中，最后返回字符串”museum/updatemuseum”，用于指定跳转到名为”museum/updatemuseum”的视图页面。
  11. updateMuseum(Museum museum, Model model): 更新博物馆信息。通过调用museumService.updateMuseum(museum)方法更新博物馆信息。如果更新成功，重新查询所有博物馆信息并添加到Model对象中，然后返回字符串”Museum/museumlist”，用于指定跳转到名为”Museum/museumlist”的视图页面。如果更新失败，返回字符串”public/false”。
  12. insertMuseum(Museum museum, Model model): 插入新的博物馆信息。通过调用museumService.insertMuseum(museum)方法插入新的博物馆信息。如果插入成功，重新查询所有博物馆信息并添加到Model对象中，然后返回字符串”Museum/museumlist”，用于指定跳转到名为”Museum/museumlist”的视图页面。如果插入失败，返回字符串”public/false”。

总体来说，这个类的功能是处理与博物馆相关的请求，包括查询、删除、更新和插入博物馆信息，并将结果存储在Model对象中，然后跳转到相应的视图页面展示结果。

管理员新闻控制类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package com.museum.controller;

import com.museum.pojo.Artifact;
import com.museum.pojo.ExcelNews;
import com.museum.pojo.ExcelParser;
import com.museum.pojo.News;
import com.museum.service.NewsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.util.List;

/**
 * 名称:NewsController
 * 描述:
 *
 * @version 1.0
 * @author:Nagisa
 * @datetime:2023-07-02 10:29
 */
@Controller
@RequestMapping("/news")
public class NewsController {
    @Autowired(required = false)
    private NewsService newsService;

    @RequestMapping("/index")
    public String toIndex(){
        return "index";
    }

    @RequestMapping("/toinsert")
    public String toInsert(){
        return "news/insertnews";
    }

    @RequestMapping("/findall")
    public String findAllNews(Model model){
        List<News> newsList=newsService.findAllNews();
        for(News news:newsList)
            System.out.println(news.getTitle());
        model.addAttribute("nlist",newsList);
        return "NewsIndex";
    }

    @RequestMapping("/findbystr")
    public String findNewsByStr(@RequestParam(value="searchStr") String searchStr,Model model){
        List<News> newsList=newsService.findNewsByStr(searchStr);
        model.addAttribute("nlist",newsList);
        return "NewsIndex";
    }

    @RequestMapping("/findbytitle")
    public String findNewsByTitle(@RequestParam(value="title") String title,Model model){
        List<News> newsList=newsService.findNewsByTitle(title);
        if(newsList.size()>0) {
            model.addAttribute("nlist", newsList);
            return "NewsIndex";
        }else {
            model.addAttribute("msg","未找到指定文章");
            return "public/false";
        }
    }

    @RequestMapping("/deletebytitle/{title}")
    public String deleteNewsByTitle(@PathVariable("title") String title, Model model){
       int i=newsService.deleteNewsByTitle(title);
       if(i>0){
           List<News> newsList=newsService.findAllNews();
           model.addAttribute("nlist",newsList);
           model.addAttribute("msg","删除成功");
           return "NewsIndex";
       }else {
           model.addAttribute("msg","未找到指定文章，删除失败");
           return "public/false";
       }
    }

    @RequestMapping("/insert")
    public String insertNews(News news,Model model){
        System.out.println("新增新闻信息："+news);
        int i=newsService.insertNews(news);
        if(i>0){
            List<News> newsList=newsService.findAllNews();
            model.addAttribute("nlist",newsList);
            model.addAttribute("msg","添加新闻成功");
            return "NewsIndex";
        }
        else {
            model.addAttribute("msg","添加失败");
            return "public/false";
        }
    }

    @ResponseBody
    @RequestMapping("/upload")
    public String uploadArtifactExcel(@RequestParam("file") MultipartFile file, HttpServletRequest request, HttpServletResponse response) {
        // 检查文件是否为空
        if (file.isEmpty()) {
            return "请选择要上传的文件";
        }
        try {
            // 示例：打印文件名和大小
            String fileName = file.getOriginalFilename();
            long fileSize = file.getSize();
            System.out.println("上传的文件名：" + fileName);
            System.out.println("文件大小：" + fileSize + " bytes");

            // 检查文件类型
            if (!fileName.toLowerCase().endsWith(".xlsx")) {
                return "请上传 *.xlsx 文件";
            }

            // 将MultipartFile对象转换为InputStream
            InputStream inputStream = file.getInputStream();

            // 创建ExcelNews对象并解析Excel文件
            ExcelNews parser = new ExcelNews();
            List<News> newsList = parser.parseExcelNews(inputStream);

            // 处理解析后的新闻对象列表
            for (News news : newsList) {
                List<News> existNewsList=newsService.findNewsByTitle(news.getTitle());
                //Artifact existArtifact = artifactAdminService.findArtifactByName(artifact.getArtname());
                //System.out.println(existNewsList);
                System.out.println("存在的新闻有："+existNewsList.size()+"条");
                if (existNewsList.size()>0) {
                    //artifact.setArtname(artifact.getArtname());
                    news.setTitle(news.getTitle());
                    System.out.println("error");
                    //artifactAdminService.updateArtifact(artifact);
                    newsService.updateNews(news);
                } else {
                    System.out.println("1");
                   // artifactAdminService.insertArtifact(artifact);
                  //  newsService.insertNews(news);
                    newsService.insertNews(news);
                }
                existNewsList.clear();
            }
            return "上传成功";
        } catch (Exception e) {
            e.printStackTrace();
            return "上传失败";
        }
    }

}

这个类是一个控制器(Controller)，主要用于处理与新闻相关的请求。以下是每个方法的功能：

  1. toIndex(): 跳转到系统首页，返回字符串”index”，用于指定跳转到名为”index”的视图页面。
  2. toInsert(): 跳转到插入新闻信息的页面，返回字符串”news/insertnews”，用于指定跳转到名为”news/insertnews”的视图页面。
  3. findAllNews(Model model): 查询所有新闻信息，并将结果存储在Model对象中。通过调用newsService.findAllNews()方法获取新闻列表，并将列表添加到Model对象的属性”nlist”中。最后，返回字符串”news/newslist”，用于指定跳转到名为”news/newslist”的视图页面。
  4. findNewsByStr(String searchStr, Model model): 根据关键词查询新闻信息。通过调用newsService.findNewsByStr(searchStr)方法获取符合条件的新闻列表，并将列表添加到Model对象的属性”nlist”中。最后，返回字符串”news/newslist”，用于指定跳转到名为”news/newslist”的视图页面。
  5. findNewsByTitle(String title, Model model): 根据新闻标题查询新闻信息。通过调用newsService.findNewsByTitle(title)方法获取符合条件的新闻列表。如果列表的大小大于0，表示查询成功，将列表添加到Model对象的属性”nlist”中，并返回字符串”news/newslist”，用于指定跳转到名为”news/newslist”的视图页面。如果列表的大小为0，表示查询失败，将错误信息添加到Model对象的属性”msg”中，然后返回字符串”public/false”。
  6. deleteNewsByTitle(String title, Model model): 根据新闻标题删除新闻信息。通过调用newsService.deleteNewsByTitle(title)方法删除对应的新闻信息。如果删除成功，重新查询所有新闻信息并添加到Model对象中，然后将成功信息添加到Model对象的属性”msg”中，最后返回字符串”news/newslist”，用于指定跳转到名为”news/newslist”的视图页面。如果删除失败，将错误信息添加到Model对象的属性”msg”中，然后返回字符串”public/false”。
  7. insertNews(News news, Model model): 插入新的新闻信息。通过调用newsService.insertNews(news)方法插入新的新闻信息。如果插入成功，重新查询所有新闻信息并添加到Model对象中，然后将成功信息添加到Model对象的属性”msg”中，最后返回字符串”news/newslist”，用于指定跳转到名为”news/newslist”的视图页面。如果插入失败，将错误信息添加到Model对象的属性”msg”中，然后返回字符串”public/false”。
  8. uploadArtifactExcel(MultipartFile file): 处理上传的新闻Excel文件。首先检查文件是否为空，然后检查文件类型是否为.xlsx格式。接下来将MultipartFile对象转换为InputStream，并使用ExcelNews对象解析Excel文件，获取新闻对象列表。然后逐个处理解析后的新闻对象列表，判断新闻是否已存在。如果新闻已存在，调用newsService.updateNews(news)方法更新新闻信息；如果新闻不存在，调用newsService.insertNews(news)方法插入新的新闻信息。最后返回上传结果的字符串。

总体来说，这个类的功能是处理与新闻相关的请求，包括查询、删除、更新和插入新闻信息，并将结果存储在Model对象中，然后跳转到相应的视图页面展示结果。另外，还提供了上传新闻Excel文件的功能。

拦截器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package com.museum.Interceptor;

/**
 * 名称:CustomerInterceptor
 * 描述:
 *
 * @version 1.0
 * @author:Nagisa
 * @datetime:2023-06-27 18:35
 */
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.museum.pojo.Admin;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Date;

public class CustomerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        HttpSession session=request.getSession();
        System.out.println("拦截器取得session:"+session.getAttribute("username"));
        Object username=session.getAttribute("username");

            if (username != null) {
                //response.resetBuffer();
                return true;
            } else {
                response.sendRedirect(request.getContextPath() + "/checkLogin/tologin");
                //response.resetBuffer();
                return false;
            }
       /* HttpSession session=request.getSession();
        Object username=session.getAttribute("username");*/



    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        System.out.println("UserAuthInterceptor postHandle------------------------");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        System.out.println("Constomer afterCompletion");
        String logdir = request.getServletContext().getRealPath("log");//获取服务器记录日志log文件所存放的目录位置 -- tomcat下的真实路径+log目录
        //路径不存在就创建
        System.out.println(logdir);
        Path logdirPath = Paths.get(logdir);
        if(Files.notExists(logdirPath)){
            Files.createDirectories(logdirPath);
            System.out.println("创建目录:"+logdirPath);
        }
        //目录存在就将数据[字符]写入
        Path logfile = Paths.get(logdir,"userlog.log");//存放日志的路径+文件名
        BufferedWriter writer = new BufferedWriter(new FileWriter(logfile.toFile(),true));//logfile.toFile() paths转换为File类型 true以追加的方式写入
        Boolean isLoggedIn=(Boolean)request.getSession().getAttribute("isLogged");
        if(isLoggedIn!=null&isLoggedIn) {
            //获取登录用户信息
            //Users user = (Users)request.getSession().getAttribute("user");
            String username = (String) request.getSession().getAttribute("username");
            // String username = user.getUsername();
            //记录user登录时间，存入日志
            String ipAddress = request.getRemoteAddr();
            // 其他相关信息，如浏览器、操作系统等
            String userAgent = request.getHeader("User-Agent");
            String message = username + " 登录时间：" + new Date() + "IP地址：" + ipAddress + "用户代理：" + userAgent;
            writer.write(message + "\r\n");
            writer.flush();
            writer.close();
        }
    }
}


这是一个实现了HandlerInterceptor接口的拦截器类，用于进行用户认证和日志记录。

  1. preHandle方法在请求处理之前进行拦截。它首先获取当前会话的HttpSession对象，并打印出session中的”username”属性。然后检查”username”是否存在，如果存在则返回true，表示允许请求继续执行；如果不存在，则通过response.sendRedirect()方法将请求重定向到登录页面，并返回false，表示拦截请求。注释掉的代码response.resetBuffer()可以用于重置响应缓冲区。
  2. postHandle方法在请求处理之后、视图渲染之前调用。在这个拦截器中，该方法没有实现具体的逻辑，只是简单地打印一条调试信息。
  3. afterCompletion方法在请求处理完成后调用，包括视图渲染完成。在该方法中，首先获取存放日志的目录位置(logdir)，如果目录不存在，则创建目录。然后获取日志文件路径(logfile)，并创建一个用于追加写入的BufferedWriter对象。接下来，判断用户是否已登录，如果是，则获取登录用户名、用户IP地址和用户代理信息，并将这些信息拼接成一条日志消息。最后，将日志消息写入日志文件，关闭写入流。

总体来说，这个拦截器用于检查用户是否已登录，并根据登录状态进行相应的操作。在用户登录时，记录用户登录信息到日志文件中。这个拦截器可以用于实现用户认证和日志记录的功能。

监听器

1
2
3
4
5
6
@WebListener 
public class UserListener implements HttpSessionBindingListener { S
    tring username; public void OnlineUserBindingListener(String username){ this.username=username; }
   public void valueBound(HttpSessionBindingEvent event) { 
       HttpSession session = event.getSession(); 
       ServletContext application = session.getServletContext(); // 把用户名放入在线列表 List onlineUserList = (List) application.getAttribute("onlineUserList"); // 第一次使用前，需要初始化 if (onlineUserList == null) { onlineUserList = new ArrayList(); application.setAttribute("onlineUserList", onlineUserList); } onlineUserList.add(this.username); System.out.println(onlineUserList); } public void valueUnbound(HttpSessionBindingEvent event) { HttpSession session = event.getSession(); ServletContext application = session.getServletContext(); // 从在线列表中删除用户名 List onlineUserList = (List) application.getAttribute("onlineUserList"); onlineUserList.remove(this.username); System.out.println(this.username + "退出。"); }

这是一个实现了HttpSessionBindingListener接口的监听器类，用于在线用户管理。

  1. OnlineUserBindingListener方法是一个自定义的构造方法，用于接收用户名参数并进行初始化。
  2. valueBound方法在绑定到HttpSession时调用。在该方法中，首先获取当前会话的HttpSession对象和ServletContext对象。然后从ServletContext中获取在线用户列表（onlineUserList），如果列表为空，则进行初始化。接下来，将当前用户名（this.username）添加到在线用户列表中，并打印在线用户列表。
  3. valueUnbound方法在从HttpSession解绑时调用。在该方法中，首先获取当前会话的HttpSession对象和ServletContext对象。然后从ServletContext中获取在线用户列表（onlineUserList），并从列表中移除当前用户名（this.username）。最后，打印当前用户名退出的消息。

总体来说，这个监听器用于在用户登录时将用户名添加到在线用户列表中，在用户退出时将用户名从在线用户列表中移除。在线用户列表存储在ServletContext中，可以在应用程序范围内共享。该监听器可以用于实现在线用户管理的功能。

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true