1 # SSM框架
2
3 # **什么是框架**
4
5 就是模板，将一些基础性的程序和代码由框架模板提供，然后程序员补充和业务需求相关的代码。
6
7 # **ssm框架组成**
8
9 s: springMvc 子框架 代替servlet类，control层
10
11 s: spring 框架系列
12
13 ​ 基本作用：创建对象（控制反转和依赖注入）
14
15 m: mybatis 框架 代替dao包，和数据库进行交互（jdbc技术），表 示model层（service包和dao包）
16
17 **补充**
18
19 ​ view层：视图层，还是使用jsp实现
20
21 # **项目演示**
22
23 ## 目标：用户管理项目
24
25 ## 操作步骤：
26
27 ### 1、创建maven项目，并配置tomcat服务器
28
29 **配置tomcat时无artifact选项解决方案**
30
31
32
33
34
35 打开
36
37
38
39 选择
40
41
42
43
44
45 ### 2、创建java和resources目录，并mark一下，新建文件夹变色
46
47 
48
49 java文件夹：存放程序员编写的java代码
50
51 resources文件夹：存放配置文件（和ssm框架相关）
52
53 ### 3、myBatis框架（替代jdbc技术）
54
55 #### 3.1 导入和mybatis相关的依赖（包）
56
57 mybatis
58
59 mybatis-spring
60
61 mysql-connector-java
62
63 ```xml
64
65 66 org.mybatis 67 mybatis 68 3.5.2 69
70
71 72 org.mybatis 73 mybatis-spring 74 2.0.2 75
76
77 78 mysql 79 mysql-connector-java 80 8.0.17 81
82 ```
83
84 #### 3.2 在resources文件夹中创建文件mybatis-config.xml
85
86 ```xml
87
88
91 92 93 94
95 ```
96
97 ### 4.spring框架
98
99 #### 4.1添加和spring相关的常用的依赖
100
101 spring-beans
102
103 spring-context/spring-context-support
104
105 spring-core
106
107 spring-expression
108
109 spring-jdbc
110
111 spring-tx
112
113 spring-web
114
115 commons-dbcp
116
117 ```xml
118 119 org.springframework 120 spring-beans 121 5.1.8.RELEASE 122
123 124 org.springframework 125 spring-context 126 5.1.8.RELEASE 127
128 129 org.springframework 130 spring-context-support 131 5.0.10.RELEASE 132
133 134 org.springframework 135 spring-core 136 5.1.8.RELEASE 137
138 139 org.springframework 140 spring-expression 141 5.1.8.RELEASE 142
143 144 org.springframework 145 spring-jdbc 146 5.0.10.RELEASE 147
148 149 org.springframework 150 spring-tx 151 5.1.8.RELEASE 152
153 154 org.springframework 155 spring-web 156 5.1.8.RELEASE 157
158
159
160 161 commons-dbcp 162 commons-dbcp 163 1.4 164
165 ```
166
167
168
169 #### 4.2在resources文件夹创建applicationContext.xml文件，用于对spring框架配置的设置
170
171 ```xml
172
173 http://www.springframework.org/schema/beans 177 http://www.springframework.org/schema/beans/spring-beans.xsd 178 http://www.springframework.org/schema/context 179 https://www.springframework.org/schema/context/spring-context.xsd"> 180 181 182
183 ```
184
185 ### 5.springmvc框架
186
187 #### 5.1添加依赖（jar包）
188
189 spring-mvc
190
191 ```xml
192
193 194 org.springframework 195 spring-webmvc 196 5.1.5.RELEASE 197
198 ```
199
200
201
202 #### 5.2在resources目录下创建springmvc-servlet.xml文件，对springmvc进行的配置设置
203
204 ```xml
205
206 http://www.springframework.org/schema/beans 210 http://www.springframework.org/schema/beans/spring-beans.xsd 211 http://www.springframework.org/schema/context 212 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd"> 213 214 215 216
217 ```
218
219 #### **注意处理**
220
221 
222
223
224
225 ### 6.在java目录下创建一些基本的包
226
227 dao :用于连接数据库
228
229 service：用于进行业务逻辑的处理
230
231 controller：用于对请求的派发和处理
232
233 pojo：将数据库的表名定义为类名，字段定义为属性,此类放在此包中
234
235 interceptor：拦截器包，使用的场景：处理非法登陆。
236
237 util：工具包，存放一些工具类，比如jdbcUtil，分页插件类等等。
238
239 test：测试包，用于测试，junit等进行测试。
240
241
242
243 ### 7.pojo中类的创建和编写
244
245 根据数据库中的表创建对应类，好处是通过操作pojo类，来代替操作数据库中的表（对象关系映射orm技术）
246
247 ```java
248 //表名对应类名
249 public class User {
250
251 //表字段对应类属性
252 private int id;
253 private String username;
254 private String password;
255
256 public int getId() {
257 return id;
258 }
259
260 public void setId(int id) {
261 this.id = id;
262 }
263
264 public String getUsername() {
265 return username;
266 }
267
268 public void setUsername(String username) {
269 this.username = username;
270 }
271
272 public String getPassword() {
273 return password;
274 }
275
276 public void setPassword(String password) {
277 this.password = password;
278 }
279 }
280
281 ```
282
283 ### 8、在resources目录下，创建database.properties文件，该文件中编写：driver，url,username,password等连接数据库的参数
284
285 ```xml
286 driver=com.mysql.jdbc.Driver
287 url=jdbc:mysql://127.0.0.1:3306/school?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
288 user=root
289 password=root
290 ```
291
292 ### 9、进行java应用项目连接数据库
293
294 **在applicationContext.xml文件下**
295
296 ```xml
297
298
299
300
301
302
303 304 305 306 307 308
309
310
311 312 313
314
315
316 317 318 319
320 ```
321
322 ### 10、在dao包中创建接口和mapper文件，在spring配置文件中配置
323
324 在mapper文件中编写sql语句
325
326
327
328 #### **a 创建接口UserMapper**
329
330 ```java
331 public interface UserMapper {
332 //登陆功能
333 public User login(@Param("xiaomao")String username,@Param("xiaogou")String password);
334 }
335 ```
336
337
338
339 #### **b 创建UserMapper文件**
340
341 ```xml
342
343
346 347 348 349 350 351 352 select * from user where username=#{xiaomao} and password=#{xiaogou} 353 354
355 ```
356
357 #### c 在applicationContext中配置对mapper文件扫描
358
359 ```xml
360
361 362 363
364 ```
365
366 #### d 在pom.xml中内添加 367 368 **将src/main/java目录下的所有*.xml文件编译到class内，不然报错：找不到mapper文件** 369 370 ```xml 371 372 373 374 375 src/main/java 376 377 **/*.xml 378 379 false 380 381 382
383 ```
384
385
386
387 ### 11、在service包中创建接口和实现类，编写业务逻辑代码
388
389 #### 接口
390
391 ```java
392 public interface UserService {
393 //登陆功能
394 public boolean login(String username,String password);
395 }
396 ```
397
398 #### 实现类
399
400 ```java
401 public class UserServiceImpl implements UserService {
402
403 @Resource//此时报错，缺少依赖：javax.annotation-api
404 private UserMapper userMapper=null;
405
406 //登陆方法
407 public boolean login(String username, String password) {
408 User user = userMapper.login(username, password);
409 boolean flag=false;
410 if(user!=null){//用户存在
411 flag=true;
412 }
413 return flag;
414 }
415 }
416 ```
417
418 #### **补充支持@Resource注解的依赖**
419
420 ```xml
421
422 423 javax.annotation 424 javax.annotation-api 425 1.3.1 426
427 ```
428
429
430
431 ### 12、在applicationContext.xml文件中对组件进行定义和扫描
432
433 #### **组件扫描**
434
435 ##### a、定义组件
436
437 编写userController类，将@Controller 放在controller包的类上
438
439 ```java
440 @Controller
441 public class UserController {
442 //编写对请求的派发和处理
443
444 }
445 ```
446
447 @Service 放在service包的实现类上
448
449 ```java
450 public interface UserService {
451 //登陆功能
452 public boolean login(String username,String password);
453 }
454 ```
455
456 ```
457 @Service
458 public class UserServiceImpl implements UserService {
459
460 @Autowired//@Resource同一功能
461 private UserMapper userMapper=null;
462
463 //登陆方法
464 public boolean login(String username, String password) {
465 User user = userMapper.login(username, password);
466 boolean flag=false;
467 if(user!=null){//用户存在
468 flag=true;
469 }
470 return flag;
471 }
472 }
473 ```
474
475
476
477 @Repository 放在dao包的实现类上（如果没有实现类，就省略）
478
479 ```java
480 public interface UserMapper {
481 //登陆功能
482 public User login(@Param("xiaomao") String username, @Param("xiaogou") String password);
483 }
484 ```
485
486 ##### b、在applicationContext.xml容器中配置，使组件生效
487
488 ```xml
489
490
491
492
493
494
495 ```
496
497 ##### c、在springmvc-serlvet.xml容器中配置，使组件生效
498
499 ```java
500
501
502 ```
503
504 ### 13、配置web.xml文件
505
506 #### a.""中添加属性 507 508 ```xml 509 http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app\_3\_0.xsd" 513 id="WebApp\_ID" version="3.0"> 514 ``` 515 516 #### b、配置监听器 517 518 ```xml 519 520 521 org.springframework.web.context.ContextLoaderListener 522 523 ``` 524 525 #### c、引入spring配置文件 526 527 ```xml 528 529 530 contextConfigLocation 531 classpath:applicationContext.xml 532 533 ``` 534 535 #### d、配置DispatcherServlet（类似于“总机调度”） 536 537 ```xml 538 539 540 DispatcherServlet 541 org.springframework.web.servlet.DispatcherServlet 542 543 contextConfigLocation 544 classpath:springmvc-servlet.xml 545 546 1 547 548 549 DispatcherServlet 550 551 / 552 553 ``` 554 555 ### 14、配置springmvc-servlet.xml 556 557 #### a、配置对组件@Controller的扫描（上述已经操作） 558 559 ```xml 560 561 562 ``` 563 564 #### b、支持注解 565 566 (@RequestMapping，@RequestParam等) 567 568 ```xml 569 570 571 ``` 572 573 #### c、配置视图解析器 574 575 - /WEB-INF/下创建jsp文件夹 576 577 - 通过逻辑视图名（jsp文件的文件名）找到真实的视图名（jsp文件的全名） 578 579 ​ 举例： 真实的视图名 index.jsp 《---逻辑视图名 jsp 580 581 ​ 比如： /WEB-INF/jsp/index.jsp 582 583 ```xml 584 585 586 587 588 589 ``` 590 591 #### d、引入静态资源 592 593 - 在webapp下创建statics文件夹 594 - 在springmvc-servlet.xml配置文件中添加 595 596 ```xml 597 598 ``` 599 600 ### 15、在controller类中创建控制器方法 601 602 ```java 603 /** 604 * @author 四两数字先生（CSDN/公众号） 605 */ 606 @Controller 607 @RequestMapping("/user") 608 public class UserController { 609 610 //private UserService userService=new UserServiceImpl(); 611 @Resource //自动装配 612 private UserService userService; 613 614 @RequestMapping("/index") 615 public String index(){ 616 return "index";//index就是逻辑视图名 617 } 618 @RequestMapping("/login") 619 public String login(@RequestParam(value = "xiaogou",required = false) String username, 620 @RequestParam(value = "xiaomao",required = false) String password){ 621 boolean flag = this.userService.login(username, password); 622 if(flag){//用户存在 623 return "success"; 624 } 625 return "failure"; 626 } 627 } 628 ``` 629 630 ### 16、编写jsp文件index.jsp 631 632 a.编写登陆表单 633 634 ```html 635

636 用户名： 637 密码： 638 639

640 ``` 641 642 b.添加 sevlet-api依赖 643 644 ```xml 645 646 647 javax.servlet 648 javax.servlet-api 649 4.0.1 650 651 ``` 652 653 b.编写登陆成功页面success.jsp 654 655 ``` 656 <%@ page contentType="text/html;charset=UTF-8" language="java" %> 657 658 659 660 661 662

登陆成功

663 664 665 ``` 666 667 668 669 c.编写登陆失败页面failure.jsp 670 671 ``` 672 <%@ page contentType="text/html;charset=UTF-8" language="java" %> 673 674 675 676 677 678

登陆失败

679 680 681 ``` 682 683 # Spring的两大核心技术 684 685 ## 控制反转/依赖注入 686 687 1、添加依赖 688 689 spring-core 690 691 spring-context 692 693 spring-beans 694 695 spring-expression 696 697 日志依赖 698 699 log4j 700 701 commons-logging 702 703 704 705 2、编写代码 706 707 验证控制反转/依赖注入 708 709 applicationContext.xml 710 711 ```xml 712 713 http://www.springframework.org/schema/beans 717 http://www.springframework.org/schema/beans/spring-beans.xsd 718 http://www.springframework.org/schema/context 719 https://www.springframework.org/schema/context/spring-context.xsd"> 720 721 722 723 724 725 726 727 ``` 728 729 person.java 730 731 ```java 732 /** 733 * @author 四两数字先生（CSDN/公众号） 734 */ 735 public class Person { 736 String name; 737 738 public String getName() { 739 return name; 740 } 741 742 public void setName(String name) { 743 this.name = name; 744 } 745 746 //speak方法 747 public void speak(){ 748 System.out.println(name+"speak hello world"); 749 } 750 } 751 752 ``` 753 754 MyTest.java 755 756 ```java 757 /** 758 * @author 四两数字先生（CSDN/公众号） 759 */ 760 public class MyTest { 761 762 @Test 763 public void test1(){ 764 /** 765 * 通过代码创建对象 766 * 通过代码给属性赋值 767 */ 768 //创建对象 769 Person person=new Person(); 770 //给属性赋值 771 person.setName("张三"); 772 //调用speak方法输出 773 person.speak(); 774 775 } 776 777 @Test 778 public void test2(){ 779 /** 780 * 通过spring技术之一：控制反转/依赖注入实现来实现 781 * 1 由spring容器创建对象 782 * 2 由spring容器给属性赋值 783 * 784 * 控制反转/依赖注入： 785 * 控制权正转：通过java代码创建对象和给属性赋值 786 * 控制权反转： 将创建对象和给属性赋值的权利反转给spring容器； 787 * 控制反转就等价于依赖注入 788 * 789 */ 790 //调用speak方法输出 791 //通过spring配置文件,获得对象ApplicationContext 792 ApplicationContext applicationContext = 793 new ClassPathXmlApplicationContext 794 ("applicationContext.xml"); 795 796 Person person1 = (Person) applicationContext.getBean("person1"); 797 798 person1.speak(); 799 800 } 801 } 802 803 ``` 804 805 ## 面向切面编程技术 806 807 在编写代码的过程中，有些代码和业务相关（比如增删改查功能），有些代码和业务没有直接关系，但是是必不可少（日志，安全权限等） 808 809 1、添加依赖 810 811 spring-core 812 813 spring-context 814 815 spring-beans 816 817 spring-expression 818 819 **和日志相关** 820 821 commons-logging 822 823 log4j 824 825 **和aop相关** 826 827 spring-aop 828 829 aopalliance 830 831 aspectjweave 832 833 # springMvc 834 835 ## **参数传递（View to Controller）** 836 837 ### **url含参传递（@RequestParam）** 838 839 ```java 840 @Controller 841 public class IndexController{ 842 843 @RequestMapping(“/welcome”) 844 845 public String index(@RequestParam(value=”username”, required=false)String username){ 846 847 848 } 849 850 } 851 ``` 852 853 ### **更精确的url含参传递(@RequestMapping)** 854 855 注意：http请求信息不仅不含请求url地址，还包含请求方法/请求参数/请求头 856 857 ``` 858 @RequestMapping(value=”/welcome”, method=RequestMethod.GET, params=”username”) 859 860 public String index(@RequestParam String username){ 861 862 logger.info(username); 863 864 return “index”; 865 866 } 867 ``` 868 869 ## **参数传递（Controller to View）** 870 871 ### **ModelAndView实现参数传递** 872 873 ```java 874 Controller 875 876 @Request Mapping(“/welcome”) 877 public String index(@RequestParam(value=”username”,required=false) String username){ 878 logger.info(); 879 ModelAndView m=new ModelAndView(); 880 m.addObject(username); 881 m.setViewName(“index”); 882 Return m; 883 } 884 ``` 885 886 index.jsp 获得容器中的参数 887 888 ```html 889

modelAndView(key:default)--->${string}

890 ``` 891 892 ### **Model实现参数传递** 893 894 需要使用到el表达式需要添加什么？ 895 896 web.xml需要修改？ 897 898 添加 web-app 后面的属性内容才能支持el表达式 899 900 ```xml 901 902 903 http://java.sun.com/xml/ns/javaee 905 http://java.sun.com/xml/ns/javaee/web-app\_3\_0.xsd" 906 version="3.0"> 907
908 ```
909
910 Controller层
911
912 ```java
913 @RequestMapping(“/welcome”)
914 public String index(@RequestParam String username, Model model){
915 logger.info();
916
917 //1
918 model.addAttribute(“username”,username);
919
920 //2
921 model.addAttribute(username);
922
923 //3
924 User user= new User();
925 user.setUserName(username); model.addAttribute(“currentUserName”,user);
926 Return “index”;
927
928 }
929 ```
930
931 Index.jsp
932
933 ```html
934

model(key:username)----> ${username}

935
936

model(key:default)-------> ${string}

937
938

model(key:currentUserName)---->${currentUseName.userName}

939 ```
940
941 ### **Map实现参数传递**
942
943 Controller
944
945 注意：Map model 必须以形参的方式引入
946
947 ```java
948 @RequestMapping(“/welcome”)
949 public String index(@RequestParam(value=”username”) String username,Map map){
950 map.put(“username”,username);
951 return “index”;
952 }
953 ```
954
955 # Ajax技术
956
957 1 register.jsp
958
959 ```java
960 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
961 962 963 964 965 996 997 998

999 <%--请求方式 1000 get 表单中参数会出现url路径中 1001 post 表单的参数不会出现在url路径中，更加安全 1002 --%> 1003

注册页面

1004 姓名： 1005

1006 密码： 1007 再次确认密码： 1008 1009

1010 1011
1012 ```
1013
1014 2 AjaxServlet.jsp
1015
1016 ```java
1017 package com.baidu.servlet;
1018
1019 import com.baidu.service.UserService;
1020 import com.baidu.service.UserServiceImpl;
1021
1022 import javax.servlet.ServletException;
1023 import javax.servlet.annotation.WebServlet;
1024 import javax.servlet.http.HttpServlet;
1025 import javax.servlet.http.HttpServletRequest;
1026 import javax.servlet.http.HttpServletResponse;
1027 import java.io.IOException;
1028 import java.io.PrintWriter;
1029
1030 /**
1031 * @author 四两数字先生（CSDN/公众号）
1032 */
1033 public class AjaxServlet extends HttpServlet {
1034
1035
1036 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
1037 this.doGet(request,response);
1038 }
1039
1040 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
1041 //编写代码
1042 //防止中文乱码
1043 request.setCharacterEncoding("utf-8");
1044 String name = request.getParameter("name1");//name是哪里
1045 boolean flag=false;
1046
1047 //模拟数据库：假设数据库中存在用户名"admin"
1048 if(name.equals("admin")){
1049 flag=true;//boolean 型返回前端时自动变成字符串"true"
1050 }
1051
1052 response.setContentType("text/html;charset=utf-8");
1053 PrintWriter writer = response.getWriter();
1054 writer.print(flag);//将flag返回给前端
1055 writer.flush();
1056 writer.close();
1057
1058 }
1059 }
1060 ```
1061
1062 3 web.xml
1063
1064 ```xml
1065
1068
1069 http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app\_3\_0.xsd" 1073 id="WebApp\_ID" version="3.0" 1074 > 1075 Archetype Created Web Application 1076 1077 1078 AjaxServlet 1079 com.baidu.servlet.AjaxServlet 1080 1081 1082 AjaxServlet 1083 /AjaxServlet 1084 1085 1086 1087 MyServlet 1088 com.baidu.servlet.MyServlet 1089 1090 1091 MyServlet 1092 /MyServlet 1093 1094
1095 ```
1096
1097 # Json格式数据
1098
1099 ```html
1100 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
1101 1102 1103 1104 1105 1175 1176 1177 <%--div中呈现普通对象--%> 1178

1179 <%--无序列表形式呈现数组--%> 1180

1181

1182 1183

1184

1185 <%--下拉列表形式呈现数组--%> 1186

1187 1188

1189 <%--表格形式呈现对象数组--%> 1190

1191 1192

1193 1194
1195 ```
1196
1197 # SpringMVC参数传递
1198
1199 ```java
1200 @Controller
1201 @RequestMapping("/user")
1202 public class UserController {
1203
1204 //private UserService userService=new UserServiceImpl();
1205 @Resource //自动装配
1206 private UserService userService;
1207
1208 //无参数的url ：localhost:8080/项目名/user/index
1209 @RequestMapping("/index")
1210 public String index(){
1211 return "index";//index就是逻辑视图名
1212 }
1213 //含参的url:localhost:8080/项目名/user/login?xiaogou=lisi&xiaomao=lisi
1214 @RequestMapping(value = "/login")
1215 public String login(@RequestParam(value = "xiaogou",required = false) String username,
1216 @RequestParam(value = "xiaomao",required = false) String password){
1217 boolean flag = this.userService.login(username, password);
1218 if(flag){//用户存在
1219 return "success";
1220 }
1221 return "failure";
1222 }
1223 //含参的url:localhost:8080/项目名/login?xiaogou=lisi&xiaomao=lisi
1224 //更精确的含参url：method = RequestMethod.POST
1225 @RequestMapping(value = "/login1" ,method = RequestMethod.POST)
1226 public String login1(@RequestParam(value = "xiaogou",required = false) String username,
1227 @RequestParam(value = "xiaomao",required = false) String password){
1228 boolean flag = this.userService.login(username, password);
1229 if(flag){//用户存在
1230 return "success";
1231 }
1232 return "failure";
1233 }
1234
1235 //Controller层传递到View
1236 //1 ModelAndView 作为返回对象
1237 @RequestMapping("/index1")
1238 public ModelAndView index1(){
1239 User user = new User();
1240 user.setId(1);
1241 user.setUsername("zhangsan");
1242 user.setPassword("123456");
1243
1244 ModelAndView modelAndView = new ModelAndView();
1245 //存放数据
1246 modelAndView.addObject("user",user);//key-value
1247 //设置逻辑视图名
1248 modelAndView.setViewName("nankeyuan");
1249 return modelAndView;
1250 }
1251
1252 //Model 作为一个容器，保存数据
1253 @RequestMapping("/index2")
1254 public String index2(Model model){
1255 model.addAttribute("str","hello model");
1256 //字符串类型 --key:string
1257 model.addAttribute("hello model2");
1258 return "nankeyuan";
1259 }
1260
1261 //Map作为容器，保存数据
1262 @RequestMapping("/index3")
1263 public String index3(Map map){
1264 map.put("mapStr","map demo");
1265 return "nankeyuan";
1266 }
1267 }
1268
1269 ```
1270
1271 # 字符乱码过滤器
1272
1273 web.xml
1274
1275 ```
1276 1277 characterFilter 1278 org.springframework.web.filter.CharacterEncodingFilter 1279 1280 1281 encoding 1282 UTF-8 1283 1284 1285 1286 forceEncoding 1287 true 1288 1289
1290 1291 characterFilter 1292 1293 /* 1294
1295
1296 ```
1297
1298 ## Restful风格路径
1299
1300 ```java
1301 //url中含参传递 restful风格路径
1302 //localhost:8080/userPro-ssm/user/index6/lisi 等价(?username=lisi)
1303 @RequestMapping("/index6/{username}")
1304 public String index6(@PathVariable(name = "username") String username){
1305 System.out.println("用户名为"+username);
1306 return "nankeyuan";
1307 }
1308 ```
1309
1310