• Java项目：SSM动漫影视网站系统

    作者主页：夜未央5788

     简介：Java领域优质创作者、Java项目、学习资料、技术互助

    文末获取源码

    项目介绍

    本项目分为前后台，前台为普通用户登录，后台为管理员登录。

    管理员角色包含以下功能：

    管理员登陆,用户管理,影片列表管理,管理影片等功能。

    用户角色包含以下功能：
    用户登录注册,用户首页,视频简介,视频播放,评论视频,查看我收藏的视频,查看我的评论等功能。

    由于本程序规模不大，可供课程设计，毕业设计学习演示之用

    环境需要

    1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
    2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
    3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可
    4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；

    5.数据库：MySql 5.7版本；

    6.6.是否Maven项目：是；

    技术栈

    1. 后端：Spring+SpringMVC+Mybatis

    2. 前端：JSP+CSS+JavaScript+jQuery

    使用说明

    1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件；

    2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;

    若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行；

    3. 将项目中application.yml配置文件中的数据库配置改为自己的配置;

    4. 运行项目，输入localhost:8080/ 登录

    运行截图

    前台界面-用户角色

     

     

     

     

     

     

    后台界面

     

     

     

    代码相关

    影片管理控制器

    1. /**
    2.  * 这个类是Film控制器，负责接收JSP的值，补充数据后，然后跳转到其他页面
    3.  */
    4. @Controller
    5. @RequestMapping("/film")
    6. public class FilmController extends BaseController {
    7. 	
    8. 	@Autowired
    9. 	private CommentService commentService;
    10. 	
    11. 	@Autowired
    12. 	private FilmService filmService;
    13. 	
    14. 	@Autowired
    15. 	private FilmDetailService filmDetailService;
    16. 	
    17. 	// --------------------------------------- 华丽分割线 ------------------------------
    18.  
    19. 	/*********************************查询列表【不分页】 @param film 电影的对象
    20. 	 * @param model model对象，Spring框架的，在这里用来向JSP页面传值
    21. 	 * @param request request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    22. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    23. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    24. 	 */
    25. 	@RequestMapping(value = "/listAll")
    26. 	public String listAll(Film film, Model model, HttpServletRequest request, HttpServletResponse response){
    27. 		List listAll = filmService.listAll();
    28. 		model.addAttribute("list", listAll);
    29. 		return "film/film";
    30. 	}
    31.  
    32. 	/**
    33. 	 * 通过传入的电影对象，具体是什么看参数名字查询数据，然后返回跳转到jsp中
    34. 	 *
    35. 	 * @param film     电影的对象
    36. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    37. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    38. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    39. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    40. 	 */
    41. 	@RequestMapping(value = "/listByEntity")
    42. 	public String listByEntity(Film film, Model model, HttpServletRequest request, HttpServletResponse response){
    43. 		List listAll = filmService.listAllByEntity(film);
    44. 		model.addAttribute("list", listAll);
    45. 		return "film/film";
    46. 	}
    47.  
    48. 	/**
    49. 	 * 通过传入的电影对象，具体是什么看参数名字然后查询数据，然后返回跳转到jsp中
    50. 	 *
    51. 	 * @param film     电影的对象
    52. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    53. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    54. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    55. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    56. 	 */
    57. 	@RequestMapping(value = "/listByMap")
    58. 	public String listByMap(Film film, Model model, HttpServletRequest request, HttpServletResponse response){
    59. 		//通过map查询
    60. 		Map params = new HashMap();
    61. 	        if(!isEmpty(film.getName())){
    62. 	        	params.put("name", film.getName());
    63. 			}
    64. 	        if(!isEmpty(film.getContent())){
    65. 	        	params.put("content", film.getContent());
    66. 			}
    67. 	        if(!isEmpty(film.getIsDelete())){
    68. 	        	params.put("isDelete", film.getIsDelete());
    69. 			}
    70. 	        if(!isEmpty(film.getPic())){
    71. 	        	params.put("pic", film.getPic());
    72. 			}
    73. 	    List listAll = filmService.listByMap(params);
    74. 		model.addAttribute("list", listAll);
    75. 		return "film/film";
    76. 	}
    77.  
    78.  
    79. 	/*********************************查询列表【分页】 @param film 电影的对象
    80. 	 * @param model model对象，Spring框架的，在这里用来向JSP页面传值
    81. 	 * @param request request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    82. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    83. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    84. 	 */
    85. 	@RequestMapping(value = "/findByObj")
    86. 	public String findByObj(Film film, Model model, HttpServletRequest request, HttpServletResponse response) {
    87. 		//分页查询
    88. 		Pager pagers = filmService.findByEntity(film);
    89. 		model.addAttribute("pagers", pagers);
    90. 		//存储查询条件
    91. 		model.addAttribute("obj", film);
    92. 		return "film/film";
    93. 	}
    94.  
    95. 	/**
    96. 	 * 根据传入的sql，去数据库中查询，最后跳转到对应的页面
    97. 	 *
    98. 	 * @param film     电影的对象
    99. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    100. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    101. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    102. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    103. 	 */
    104. 	@RequestMapping(value = "/findBySql")
    105. 	public String findBySql(Film film, Model model, HttpServletRequest request, HttpServletResponse response) {
    106. 		//分页查询
    107. 		String sql = "SELECT * FROM film WHERE isDelete = 0 ";
    108.         if(!isEmpty(film.getName())){
    109.         	sql += " and name like '%"+film.getName()+"%'";
    110. 		}
    111.         if(!isEmpty(film.getContent())){
    112.         	sql += " and content like '%"+film.getContent()+"%'";
    113. 		}
    114.         if(!isEmpty(film.getIsDelete())){
    115.         	sql += " and isDelete like '%"+film.getIsDelete()+"%'";
    116. 		}
    117.         if(!isEmpty(film.getPic())){
    118.         	sql += " and pic like '%"+film.getPic()+"%'";
    119. 		}
    120.        sql += " ORDER BY ID DESC ";
    121. 		Pager pagers = filmService.findBySqlRerturnEntity(sql);
    122. 		model.addAttribute("pagers", pagers);
    123. 		//存储查询条件
    124. 		model.addAttribute("obj", film);
    125. 		return "film/film";
    126. 	}
    127.  
    128.  
    129. 	/**
    130. 	 * 根据传入的map，查询数据库后，根据return的值跳转到对应的JSP中
    131. 	 *
    132. 	 * @param film     电影的对象
    133. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    134. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    135. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    136. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    137. 	 */
    138. 	@RequestMapping(value = "/findByMap")
    139. 	public String findByMap(Film film, Model model, HttpServletRequest request, HttpServletResponse response) {
    140. 		//通过map查询
    141. 		Map params = new HashMap();
    142.         if(!isEmpty(film.getName())){
    143.         	params.put("name", film.getName());
    144. 		}
    145.         if(!isEmpty(film.getContent())){
    146.         	params.put("content", film.getContent());
    147. 		}
    148.         if(!isEmpty(film.getIsDelete())){
    149.         	params.put("isDelete", film.getIsDelete());
    150. 		}
    151.         if(!isEmpty(film.getPic())){
    152.         	params.put("pic", film.getPic());
    153. 		}
    154. 		//分页查询
    155. 		Pager pagers = filmService.findByMap(params);
    156. 		model.addAttribute("pagers", pagers);
    157. 		//存储查询条件
    158. 		model.addAttribute("obj", film);
    159. 		return "film/film";
    160. 	}
    161.  
    162. 	/**********************************【增删改】 @return 一个字符串，根据字符串的值来跳转到相应页面*/
    163. 	@RequestMapping(value = "/add")
    164. 	public String add() {
    165. 		return "film/add";
    166. 	}
    167.  
    168. 	/**
    169. 	 * 根据ID查看表的某一条数据
    170. 	 *
    171. 	 * @param id    主键ID
    172. 	 * @param model model对象，Spring框架的，在这里用来向JSP页面传值
    173. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    174. 	 */
    175. 	@RequestMapping(value = "/view")
    176. 	public String view(Integer id,Model model) {
    177. 		Film obj = filmService.load(id);
    178. 		List listBySqlReturnEntity = commentService.listBySqlReturnEntity("SELECT * FROM comment WHERE filmId="+id+" order by  addTime desc");
    179. 		model.addAttribute("obj",obj);
    180. 		model.addAttribute("list",listBySqlReturnEntity);
    181. 		//查询视频列表
    182. 		List listBySqlReturnEntity2 = filmDetailService.listBySqlReturnEntity("SELECT * FROM film_detail WHERE filmId = "+id);
    183. 		model.addAttribute("datails",listBySqlReturnEntity2);
    184. 		return "film/view";
    185. 	}
    186.  
    187. 	/**
    188. 	 * 添加数据后跳转到jsp
    189. 	 *
    190. 	 * @param file     文件对象，对应前端传来的文件，比如图片，视频等
    191. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    192. 	 * @param film     电影的对象
    193. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    194. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    195. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    196. 	 * @throws IllegalStateException the illegal state exception
    197. 	 * @throws IOException           the io exception
    198. 	 */
    199. 	@RequestMapping(value = "/exAdd")
    200. 	public String exAdd(@RequestParam(value = "file", required = false) MultipartFile file,HttpServletRequest request,Film film, Model model, HttpServletResponse response) throws IllegalStateException, IOException {
    201. 		
    202. 		if (!file.isEmpty()){
    203. 			System.out.println("开始");  
    204. 	          long  startTime=System.currentTimeMillis();
    205. 	          System.out.println("fileName："+file.getOriginalFilename());
    206. 	          String n = UUIDUtils.create();
    207. 	          String path=Thread.currentThread().getContextClassLoader().getResource("").getPath().substring(0,Thread.currentThread().getContextClassLoader().getResource("").getPath().length()-16)+"/upload/"+n+file.getOriginalFilename();
    208. 	          System.out.println("===================================================");
    209. 	          System.out.println(path);
    210. 	          File newFile=new File(path);
    211. 	          //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
    212. 	          file.transferTo(newFile);
    213. 	          film.setPic("\\upload\\"+n+file.getOriginalFilename());
    214. 		}
    215. 		film.setIsDelete(0);
    216. 		filmService.insert(film);
    217. 		return "redirect:/film/findBySql.action";
    218. 	}
    219.  
    220.  
    221. 	/**
    222. 	 * 跳转到更新页面
    223. 	 *
    224. 	 * @param id    主键ID
    225. 	 * @param model model对象，Spring框架的，在这里用来向JSP页面传值
    226. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    227. 	 */
    228. 	@RequestMapping(value = "/update")
    229. 	public String update(Integer id,Model model) {
    230. 		Film obj = filmService.load(id);
    231. 		model.addAttribute("obj",obj);
    232. 		return "film/update";
    233. 	}
    234.  
    235. 	/**
    236. 	 *更新数据后跳转到JSP
    237. 	 *
    238. 	 * @param file     文件对象，对应前端传来的文件，比如图片，视频等
    239. 	 * @param film     电影的对象
    240. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    241. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    242. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    243. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    244. 	 * @throws IllegalStateException the illegal state exception
    245. 	 * @throws IOException           the io exception
    246. 	 */
    247. 	@RequestMapping(value = "/exUpdate")
    248. 	public String exUpdate(@RequestParam(value = "file", required = false) MultipartFile file,Film film, Model model, HttpServletRequest request, HttpServletResponse response) throws IllegalStateException, IOException {
    249. 		if (!file.isEmpty()){
    250. 			System.out.println("开始");  
    251. 	          long  startTime=System.currentTimeMillis();
    252. 	          System.out.println("fileName："+file.getOriginalFilename());
    253. 	          String n = UUIDUtils.create();
    254. 	          String path=Thread.currentThread().getContextClassLoader().getResource("").getPath().substring(0,Thread.currentThread().getContextClassLoader().getResource("").getPath().length()-16)+"/upload/"+n+file.getOriginalFilename();
    255. 	          System.out.println("===================================================");
    256. 	          System.out.println(path);
    257. 	          File newFile=new File(path);
    258. 	          //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
    259. 	          file.transferTo(newFile);
    260. 	          film.setPic("\\upload\\"+n+file.getOriginalFilename());
    261. 		}
    262. 		filmService.updateById(film);
    263. 		return "redirect:/film/findBySql.action";
    264. 	}
    265.  
    266. 	/**
    267. 	 * 数据删除
    268. 	 *
    269. 	 * @param id       主键ID
    270. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    271. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    272. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    273. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    274. 	 */
    275. 	@RequestMapping(value = "/delete")
    276. 	public String delete(Integer id, Model model, HttpServletRequest request, HttpServletResponse response) {
    277. 		Film load = filmService.load(id);
    278. 		load.setIsDelete(1);
    279. 		filmService.updateById(load);
    280. 		return "redirect:/film/findBySql.action";
    281. 	}
    282. 	
    283. 	// --------------------------------------- 华丽分割线 ------------------------------
    284. 	// --------------------------------------- 【下面是ajax操作的方法。】 ------------------------------
    285.  
    286. 	/*********************************查询列表【不分页】 @param film 电影的对象
    287. 	 * @param request request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    288. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    289. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    290. 	 */
    291. 	@RequestMapping(value = "/listAllJson", method = RequestMethod.POST)
    292. 	@ResponseBody
    293. 	public String listAllJson(Film film, HttpServletRequest request, HttpServletResponse response){
    294. 		List listAll = filmService.listAll();
    295. 		JSONObject jsonObject = new JSONObject();
    296. 		jsonObject.put("list", listAll);
    297. 		jsonObject.put("obj", film);
    298. 		return jsonObject.toString();
    299. 	}
    300.  
    301. 	/**
    302. 	 * 根据传入的对象查询数据，最后返回json格式的数据
    303. 	 *
    304. 	 * @param film     电影的对象
    305. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    306. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    307. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    308. 	 */
    309. 	@RequestMapping(value = "/listByEntityJson", method = RequestMethod.POST)
    310. 	@ResponseBody
    311. 	public String listByEntityJson(Film film,  HttpServletRequest request, HttpServletResponse response){
    312. 		List listAll = filmService.listAllByEntity(film);
    313. 		JSONObject jsonObject = new JSONObject();
    314. 		jsonObject.put("list", listAll);
    315. 		jsonObject.put("obj", film);
    316. 		return jsonObject.toString();
    317. 	}
    318.  
    319. 	/**
    320. 	 * 根据传入的map查询数据，最后返回json格式的数据
    321. 	 *
    322. 	 * @param film     电影的对象
    323. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    324. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    325. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    326. 	 */
    327. 	@RequestMapping(value = "/listByMapJson", method = RequestMethod.POST)
    328. 	@ResponseBody
    329. 	public String listByMapJson(Film film,HttpServletRequest request, HttpServletResponse response){
    330. 		//通过map查询
    331. 		Map params = new HashMap();
    332. 	        if(!isEmpty(film.getName())){
    333. 	        	params.put("name", film.getName());
    334. 			}
    335. 	        if(!isEmpty(film.getContent())){
    336. 	        	params.put("content", film.getContent());
    337. 			}
    338. 	        if(!isEmpty(film.getIsDelete())){
    339. 	        	params.put("isDelete", film.getIsDelete());
    340. 			}
    341. 	        if(!isEmpty(film.getPic())){
    342. 	        	params.put("pic", film.getPic());
    343. 			}
    344. 	    List listAll = filmService.listByMap(params);
    345. 	    JSONObject jsonObject = new JSONObject();
    346. 		jsonObject.put("list", listAll);
    347. 		jsonObject.put("obj", film);
    348. 		return jsonObject.toString();
    349. 	}
    350.  
    351.  
    352. 	/**
    353. 	 * 根据传入的对象查询数据，最后返回json格式的数据
    354. 	 *
    355. 	 * @param film     电影的对象
    356. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    357. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    358. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    359. 	 */
    360. 	@RequestMapping(value = "/findByObjJson", method = RequestMethod.POST)
    361. 	@ResponseBody
    362. 	public String findByObjByEntityJson(Film film, HttpServletRequest request, HttpServletResponse response) {
    363. 		//分页查询
    364. 		Pager pagers = filmService.findByEntity(film);
    365. 		JSONObject jsonObject = new JSONObject();
    366. 		jsonObject.put("pagers", pagers);
    367. 		jsonObject.put("obj", film);
    368. 		return jsonObject.toString();
    369. 	}
    370.  
    371.  
    372. 	/**
    373. 	 * 根据传入的对象查询数据，最后返回json格式的数据
    374. 	 *
    375. 	 * @param film     电影的对象
    376. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    377. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    378. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    379. 	 */
    380. 	@RequestMapping(value = "/findByMapJson",  method = RequestMethod.POST)
    381. 	@ResponseBody
    382. 	public String findByMapJson(Film film,HttpServletRequest request, HttpServletResponse response) {
    383. 		//通过map查询
    384. 		Map params = new HashMap();
    385.         if(!isEmpty(film.getName())){
    386.         	params.put("name", film.getName());
    387. 		}
    388.         if(!isEmpty(film.getContent())){
    389.         	params.put("content", film.getContent());
    390. 		}
    391.         if(!isEmpty(film.getIsDelete())){
    392.         	params.put("isDelete", film.getIsDelete());
    393. 		}
    394.         if(!isEmpty(film.getPic())){
    395.         	params.put("pic", film.getPic());
    396. 		}
    397. 		//分页查询
    398. 		Pager pagers = filmService.findByMap(params);
    399. 		JSONObject jsonObject = new JSONObject();
    400. 		jsonObject.put("pagers", pagers);
    401. 		jsonObject.put("obj", film);
    402. 		return jsonObject.toString();
    403. 	}
    404.  
    405.  
    406. 	/**
    407. 	 * 根据传入的数据进行添加操作，返回是否成功的json
    408. 	 *
    409. 	 * @param film     电影的对象
    410. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    411. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    412. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    413. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    414. 	 */
    415. 	@RequestMapping(value = "/exAddJson", method = RequestMethod.POST)
    416. 	@ResponseBody
    417. 	public String exAddJson(Film film, Model model, HttpServletRequest request, HttpServletResponse response) {
    418. 		filmService.insert(film);
    419. 		JSONObject jsonObject = new JSONObject();
    420. 		jsonObject.put("message", "添加成功");
    421. 		return jsonObject.toString();
    422. 	}
    423.  
    424.  
    425. 	/**
    426. 	 * 根据传入的数据进行更新操作，返回是否成功的json
    427. 	 *
    428. 	 * @param film     电影的对象
    429. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    430. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    431. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    432. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    433. 	 */
    434. 	@RequestMapping(value = "/exUpdate.json", method = RequestMethod.POST)
    435. 	@ResponseBody
    436. 	public String exUpdateJson(Film film, Model model, HttpServletRequest request, HttpServletResponse response) {
    437. 		//1.通过实体类修改，可以多传修改条件
    438. 		filmService.updateById(film);
    439. 		//2.通过主键id修改
    440. 		//filmService.updateById(film);
    441. 		JSONObject jsonObject = new JSONObject();
    442. 		jsonObject.put("message", "修改成功");
    443. 		return jsonObject.toString();
    444. 	}
    445.  
    446. 	/**
    447. 	 * 根据传入的数据进行更删除操作，返回是否成功的json
    448. 	 *
    449. 	 * @param id       主键ID
    450. 	 * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    451. 	 * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    452. 	 * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    453. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    454. 	 */
    455. 	@RequestMapping(value = "/delete.json", method = RequestMethod.POST)
    456. 	@ResponseBody
    457. 	public String exDeleteJson(Integer id, Model model, HttpServletRequest request, HttpServletResponse response) {
    458. 		///1.通过主键删除
    459. 		filmService.deleteById(id);
    460. 		/*以下是多种删除方式*/
    461. //		//2.通过实体条件删除
    462. //		filmService.deleteByEntity(film);
    463. //		//3.通过参数删除
    464. //        //通过map查询
    465. //		Map params = new HashMap();
    466. //		
    467. //        if(!isEmpty(film.getName())){
    468. //        	params.put("name", film.getName());
    469. //		}
    470. //       
    471. //        if(!isEmpty(film.getContent())){
    472. //        	params.put("content", film.getContent());
    473. //		}
    474. //       
    475. //        if(!isEmpty(film.getIsDelete())){
    476. //        	params.put("isDelete", film.getIsDelete());
    477. //		}
    478. //       
    479. //        if(!isEmpty(film.getPic())){
    480. //        	params.put("pic", film.getPic());
    481. //		}
    482. //       
    483. //		filmService.deleteByMap(params);
    484. //		//4.状态删除
    485. //		Film load = filmService.getById(film.getId())
    486. //		load.setIsDelete(1);
    487. //		filmService.updateById(load);
    488. 		//5.状态删除
    489. 		//Film load = filmService.load(id);
    490. 		//load.setIsDelete(1);
    491. 		//filmService.updateById(load);
    492. 		JSONObject jsonObject = new JSONObject();
    493. 		jsonObject.put("message", "删除成功");
    494. 		return jsonObject.toString();
    495. 	}
    496.  
    497. 	/**
    498. 	 * 保存上传的文件然后跳转到对应的JSP
    499. 	 *
    500. 	 * @param file    文件对象，对应前端传来的文件，比如图片，视频等
    501. 	 * @param request request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    502. 	 * @param model   model对象，Spring框架的，在这里用来向JSP页面传值
    503. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    504. 	 */
    505. 	@RequestMapping(value = "/saveFile")
    506.     public String saveFile(@RequestParam(value = "file", required = false) MultipartFile file, HttpServletRequest request, Model model) {  
    507.   
    508.         System.out.println("开始");  
    509.         String path = request.getSession().getServletContext().getRealPath("/upload");  
    510.         String fileName = file.getOriginalFilename();  
    511.         System.out.println(path);  
    512.         File targetFile = new File(path, fileName);  
    513.         if(!targetFile.exists()){  
    514.             targetFile.mkdirs();  
    515.         }  
    516.         //保存  
    517.         try {  
    518.             file.transferTo(targetFile);  
    519.         } catch (Exception e) {  
    520.             e.printStackTrace();  
    521.         }  
    522.   
    523.         return "";  
    524.     }
    525.  
    526.  
    527. 	/**
    528. 	 * 保存上传的多个文件然后跳转到对应的JSP
    529. 	 *
    530. 	 * @param files   文件对象，对应前端传来的文件，比如图片，视频等s
    531. 	 * @param id      主键ID
    532. 	 * @param request request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    533. 	 * @return 一个字符串，根据字符串的值来跳转到相应页面
    534. 	 */
    535. 	@RequestMapping(value = "/saveFiles")
    536.     public String saveFiles(@RequestParam("file") CommonsMultipartFile[] files,Integer id,HttpServletRequest request){
    537. 		for(int i = 0;i
    538. 	      	System.out.println("fileName---------->" + files[i].getOriginalFilename());
    539. 		  if(!files[i].isEmpty()){
    540.             int pre = (int) System.currentTimeMillis();
    541. 	     	try {
    542. 			//拿到输出流，同时重命名上传的文件
    543. 			 String filePath = request.getRealPath("/upload");
    544. 			 File f=new File(filePath);
    545. 			 if(!f.exists()){
    546. 				f.mkdirs();
    547. 			 }
    548. 		     String fileNmae=new Date().getTime() + files[i].getOriginalFilename();
    549. 		     File file=new File(filePath+"/"+pre + files[i].getOriginalFilename());
    550. 			  if(!file.exists()){
    551. 				  file.createNewFile();
    552. 			 }
    553. 			  files[i].transferTo(file);
    554. 		     } catch (Exception e) {
    555. 				e.printStackTrace();
    556. 				System.out.println("上传出错");
    557. 			 }
    558. 		  }
    559. 		}
    560. 	  return "";
    561. 	}
    562.  // --------------------------------------- 华丽分割线 ------------------------------
    563. 	
    564. 	
    565. }

    登录管理控制器

    1. /**
    2.  * 这个类是Login控制器，负责接收JSP的值，补充数据后，然后跳转到其他页面
    3.  */
    4. @Controller
    5. @RequestMapping("/login")
    6. public class LoginController  extends BaseController{
    7. 	
    8. 	@Autowired
    9. 	private ManageService manageService;
    10. 	
    11. 	@Autowired
    12. 	private UserService userService;
    13. 	
    14. 	@Autowired
    15. 	private CommentService commentService;
    16. 	
    17. 	@Autowired
    18. 	private FilmService filmService;
    19. 	
    20. 	@Autowired
    21. 	private CollectService collectService;
    22.  
    23.     /**
    24.      * Login string.
    25.      *
    26.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    27.      */
    28.     @RequestMapping("/login")
    29. 	public String login(){
    30. 		return "login/login";
    31. 	}
    32.  
    33.     /**
    34.      * U login string.
    35.      *
    36.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    37.      */
    38.     @RequestMapping("/uLogin")
    39. 	public String uLogin(){
    40. 		return "login/uLogin";
    41. 	}
    42.  
    43.     /**
    44.      * 跳转主页
    45.      *
    46.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    47.      */
    48.     @RequestMapping("/index")
    49. 	public String index(){
    50. 		
    51. 		return "login/index";
    52. 	}
    53.  
    54.     /**
    55.      * To login string.
    56.      *
    57.      * @param manage   管理员类的对象
    58.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    59.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    60.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    61.      */
    62.     @RequestMapping("/toLogin")
    63. 	@ResponseBody
    64. 	public String toLogin(Manage manage, HttpServletRequest request, HttpServletResponse response){
    65. 		Manage byEntity = manageService.getByEntity(manage);
    66. 		
    67. 		JSONObject jsonObject = new JSONObject();
    68. 		
    69. 		if(byEntity == null){
    70. 			
    71. 			jsonObject.put("res", 0);
    72. 		
    73. 		}else{
    74. 			request.getSession().setAttribute("role", byEntity.getType());
    75. 			request.getSession().setAttribute("mid", byEntity.getId());
    76. 			request.getSession().setAttribute("xm",byEntity.getRealName());
    77. 			jsonObject.put("res", 1);
    78. 		}
    79. 		
    80. 		return jsonObject.toString();
    81. 	}
    82.  
    83.     /**
    84.      * Ulogin string.
    85.      *
    86.      * @param manage   管理员类的对象
    87.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    88.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    89.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    90.      */
    91.     @RequestMapping("/ulogin")
    92. 	public String ulogin(User manage, HttpServletRequest request, HttpServletResponse response){
    93. 		User byEntity = userService.getByEntity(manage);
    94. 		
    95. 		JSONObject jsonObject = new JSONObject();
    96. 		
    97. 		if(byEntity == null){
    98. 			return "redirect:/login/uIndex.action";
    99. 		}else{
    100. 			request.getSession().setAttribute("role", 1);
    101. 			request.getSession().setAttribute("mid", byEntity.getId());
    102. 			request.getSession().setAttribute("xm",byEntity.getName());
    103. 			return "redirect:/login/uIndex.action";
    104. 		}
    105. 	}
    106.  
    107.  
    108.     /**
    109.      * Res string.
    110.      *
    111.      * @param user 用户对象
    112.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    113.      */
    114.     @RequestMapping("/res")
    115. 	public String res(User user) {
    116. 		user.setIsDelete(0);
    117. 		userService.insert(user);
    118. 		return "redirect:/login/uIndex.action";
    119. 	}
    120.  
    121.  
    122.     /**
    123.      * U index string.
    124.      *
    125.      * @param type     用户的类型，根据值来判断
    126.      * @param name     名字
    127.      * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    128.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    129.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    130.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    131.      */
    132.     @RequestMapping(value = "/uIndex")
    133. 	public String uIndex(Integer type,String name, Model model, HttpServletRequest request, HttpServletResponse response) {
    134. 		String sql = "SELECT * FROM film WHERE isDelete = 0 ";
    135. 		if (type != null ){
    136. 			sql+=" and type = "+type;
    137. 		}
    138. 		if (StringUtils.isNoneBlank(name)){
    139. 			sql += " and name like '%"+name+"%'";
    140. 		}
    141. 		sql+=" order by id desc";
    142. 		Pager findBySqlRerturnEntity = filmService.findBySqlRerturnEntity(sql);
    143. 		model.addAttribute("type", type);
    144. 		model.addAttribute("name", name);
    145. 		model.addAttribute("pagers", findBySqlRerturnEntity);
    146. 		
    147. 		String sql2 = "SELECT * FROM film WHERE isDelete = 0 order by id desc limit 0,10 ";
    148. 		List findBySqlRerturnEntity2 = filmService.listBySqlReturnEntity(sql2);
    149. 		model.addAttribute("pagers2", findBySqlRerturnEntity2);
    150. 		return "login/uIndex";
    151. 	}
    152.  
    153.  
    154.     /**
    155.      * Tuichu string.
    156.      *
    157.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    158.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    159.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    160.      */
    161.     @RequestMapping("/tuichu")
    162. 	public String tuichu( HttpServletRequest request, HttpServletResponse response){
    163. 		HttpSession session = request.getSession();
    164. 		session.invalidate();
    165. 		return "redirect:/login/login.action";
    166. 	}
    167.  
    168.  
    169.     /**
    170.      * 根据ID查看表的某一条数据
    171.      *
    172.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    173.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    174.      * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    175.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    176.      */
    177.     @RequestMapping("/view")
    178. 	public String view( HttpServletRequest request, HttpServletResponse response, Model model){
    179. 		Object attribute = request.getSession().getAttribute("mid");
    180. 		if (attribute == null){
    181. 			return "redirect:/login/uIndex.action";
    182. 		}
    183. 		Integer userId = Integer.valueOf(attribute.toString());
    184. 		User load = userService.load(userId);
    185. 		model.addAttribute("obj", load);
    186. 		
    187. 		return "login/view";
    188. 	}
    189.  
    190.     /**
    191.      * Sc string.
    192.      *
    193.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    194.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    195.      * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    196.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    197.      */
    198.     @RequestMapping("/sc")
    199. 	public String sc( HttpServletRequest request, HttpServletResponse response, Model model){
    200. 		Object attribute = request.getSession().getAttribute("mid");
    201. 		if (attribute == null){
    202. 			return "redirect:/login/uIndex.action";
    203. 		}
    204. 		Integer userId = Integer.valueOf(attribute.toString());
    205. 		User load = userService.load(userId);
    206. 		model.addAttribute("obj", load);
    207. 		List listBySqlReturnEntity = collectService.listBySqlReturnEntity("SELECT * FROM collect WHERE userId = "+userId);
    208. 		model.addAttribute("list", listBySqlReturnEntity);
    209. 		return "login/sc";
    210. 	}
    211.  
    212.  
    213.     /**
    214.      * Pl string.
    215.      *
    216.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    217.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    218.      * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    219.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    220.      */
    221.     @RequestMapping("/pl")
    222. 	public String pl( HttpServletRequest request, HttpServletResponse response, Model model){
    223. 		Object attribute = request.getSession().getAttribute("mid");
    224. 		if (attribute == null){
    225. 			return "redirect:/login/uIndex.action";
    226. 		}
    227. 		Integer userId = Integer.valueOf(attribute.toString());
    228. 		User load = userService.load(userId);
    229. 		model.addAttribute("obj", load);
    230. 		List listBySqlReturnEntity = commentService.listBySqlReturnEntity("SELECT * FROM comment WHERE userId = "+userId);
    231. 		model.addAttribute("list", listBySqlReturnEntity);
    232. 		return "login/pl";
    233. 	}
    234.  
    235.  
    236.     /**
    237.      * Delete sc string.
    238.      *
    239.      * @param id       主键ID
    240.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    241.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    242.      * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    243.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    244.      */
    245.     @RequestMapping("/deleteSc")
    246. 	public String deleteSc( Integer id,HttpServletRequest request, HttpServletResponse response, Model model){
    247. 		Object attribute = request.getSession().getAttribute("mid");
    248. 		if (attribute == null){
    249. 			return "redirect:/login/uIndex.action";
    250. 		}
    251. 		Integer userId = Integer.valueOf(attribute.toString());
    252. 		collectService.deleteById(id);
    253. 		return "redirect:/login/sc.action";
    254. 	}
    255.  
    256.  
    257.     /**
    258.      * Utuichu string.
    259.      *
    260.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    261.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    262.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    263.      */
    264.     @RequestMapping("/utuichu")
    265. 	public String utuichu( HttpServletRequest request, HttpServletResponse response){
    266. 		HttpSession session = request.getSession();
    267. 		session.invalidate();
    268. 		return "redirect:/login/uIndex.action";
    269. 	}
    270.  
    271.     /**
    272.      * Toupdate string.
    273.      *
    274.      * @param user     用户对象
    275.      * @param request  request对象，JSP内置对象，不一定用到，一般用来做传值或者保存数据到前台，或者获取session
    276.      * @param response response对象，JSP内置对象，不一定用到，一般用来向前端返回值
    277.      * @param model    model对象，Spring框架的，在这里用来向JSP页面传值
    278.      * @return 一个字符串，根据字符串的值来跳转到相应页面
    279.      */
    280. //toupdate
    281. 	@RequestMapping("/toupdate")
    282. 	public String toupdate(User user, HttpServletRequest request, HttpServletResponse response, Model model){
    283. 		Object attribute = request.getSession().getAttribute("mid");
    284. 		if (attribute == null){
    285. 			return "redirect:/login/uIndex.action";
    286. 		}
    287. 		Integer userId = Integer.valueOf(attribute.toString());
    288. 		User load = userService.load(userId);
    289. 		load.setEmail(user.getEmail());
    290. 		load.setIdCard(user.getIdCard());
    291. 		load.setName(user.getName());
    292. 		load.setNickname(user.getNickname());
    293. 		load.setPassword(user.getPassword());
    294. 		load.setPhone(user.getPhone());
    295. 		userService.updateById(load);
    296. 		HttpSession session = request.getSession();
    297. 		session.invalidate();
    298. 		return "redirect:/login/uIndex.action";
    299. 	}
    300. 	
    301. 	
    302. 	@RequestMapping("/head")
    303. 	private String head(){
    304. 		return "inc/head";
    305. 	}
    306. 	
    307. 	@RequestMapping("/wel")
    308. 	private String left(){
    309. 		return "login/welcome";
    310. 	}
    311. 	
    312. }

    如果也想学习本系统，下面领取。关注并回复：131ssm

  • 相关阅读:
    对硬件编程的一点理解---vitis使用
    TCP/IP五层协议栈(2)
    Vue---8种组件传值方式总结，总有一款适合你
    Vue3 封装 Element Plus Menu 无限级菜单组件
    华为机试 - 连续出牌数量
    长度最小的子数组（滑动窗口）
    I.MX6UL的uboot移植
    湘潭大学软件工程数据库2（题型，复习资源和计划）
    CC攻击演示
    【稳定性】关于缩短MTTR的探索
  • 原文地址：https://blog.csdn.net/hanyunlong1989/article/details/126542928