精华内容
下载资源
问答
  • 不知道你用的是原始的jsp还是struts之类的框架,如果是后者,有相应的标记库,直接绑定就可以了。 再不会google些例子程序自己学习下。整齐地输出可以用table。 不知道你用的是原始的jsp还是struts之类的框架,...
    整齐地输出可以用table。
    不知道你用的是原始的jsp还是struts之类的框架,如果是后者,有相应的标记库,直接绑定就可以了。
    再不会google些例子程序自己学习下。整齐地输出可以用table。
    不知道你用的是原始的jsp还是struts之类的框架,如果是后者,有相应的标记库,直接绑定就可以了。

    再不会google些例子程序自己学习下。

    标准标签方式
    页面头部引入<@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" /> 

    有好多年不搞Java Web开发了,这几天正好国庆放假,放松之余也有兴趣回头看看Java Web开发技术的基础。

    我们都知道,Servlet是Java Web开发的重要基础,但是由于Servlet开发相对繁琐,代码量庞大而且不易维护,美工无法参与界面设计开发等不足,于是就诞生了jsp。jsp是对servlet开发模型的重要升级。有了jsp,Java Web开发技术才真正被广泛使用。

    一、Servlet

    在Java Web开发当中,新建一个类继承(派生)自HttpServlet类即可创建一个Servlet。

    比如:

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. @WebServlet(name="firstServlet",urlPatterns={"/firstServlet"})  
    2. public class FirstServlet extends HttpServlet {  
    3.   
    4.     /** 
    5.      * Constructor of the object. 
    6.      */  
    7.     public FirstServlet() {  
    8.         super();  
    9.     }  
    10.   
    11.     /** 
    12.      * Destruction of the servlet. <br> 
    13.      */  
    14.     public void destroy() {  
    15.         super.destroy(); // Just puts "destroy" string in log  
    16.         // Put your code here  
    17.     }  
    18.   
    19.     /** 
    20.      * The doGet method of the servlet. <br> 
    21.      * 
    22.      * This method is called when a form has its tag value method equals to get. 
    23.      *  
    24.      * @param request the request send by the client to the server 
    25.      * @param response the response send by the server to the client 
    26.      * @throws ServletException if an error occurred 
    27.      * @throws IOException if an error occurred 
    28.      */  
    29.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
    30.             throws ServletException, IOException {  
    31.   
    32.         response.setContentType("text/html");  
    33.         PrintWriter out = response.getWriter();  
    34.         out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");  
    35.         out.println("<HTML>");  
    36.         out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>");  
    37.         out.println("  <BODY>");  
    38.         out.print("    This is ");  
    39.         out.print(this.getClass());  
    40.         out.println(", using the GET method");  
    41.         out.println("  </BODY>");  
    42.         out.println("</HTML>");  
    43.         out.flush();  
    44.         out.close();  
    45.     }  
    46.   
    47.     /** 
    48.      * The doPost method of the servlet. <br> 
    49.      * 
    50.      * This method is called when a form has its tag value method equals to post. 
    51.      *  
    52.      * @param request the request send by the client to the server 
    53.      * @param response the response send by the server to the client 
    54.      * @throws ServletException if an error occurred 
    55.      * @throws IOException if an error occurred 
    56.      */  
    57.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
    58.             throws ServletException, IOException {  
    59.   
    60.         response.setContentType("text/html");  
    61.         PrintWriter out = response.getWriter();  
    62.         out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");  
    63.         out.println("<HTML>");  
    64.         out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>");  
    65.         out.println("  <BODY>");  
    66.         out.print("    This is ");  
    67.         out.print(this.getClass());  
    68.         out.println(", using the POST method");  
    69.         out.println("  </BODY>");  
    70.         out.println("</HTML>");  
    71.         out.flush();  
    72.         out.close();  
    73.     }  
    74.   
    75.     /** 
    76.      * Initialization of the servlet. <br> 
    77.      * 
    78.      * @throws ServletException if an error occurs 
    79.      */  
    80.     public void init() throws ServletException {  
    81.         // Put your code here  
    82.     }  
    83.   
    84. }  
    这段代码是在myeclipse工具当中创建servlet时自动生成的,可以看到我们新建的FirstServlet类继承自HttpServlet。而且又实现了里面的doGet(Get请求时调用的方法)、doPost(Post请求时调用的方法)、init(初始化对象)、destroy(销毁对象)。值得注意的是我们采用了Annotation的方式进行了修饰,即:@WebServlet(name="firstServlet",urlPatterns={"/firstServlet"})。这是servlet3.0开始推荐的,以前采用的方式是在web.xml里面添加servlet和servlet-mapping配置。比如:

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
    1. <servlet>  
    2.     <servlet-name>firstServlet</servlet-name>  
    3.     <servlet-class>包名.FirstServlet</servlet-class>  
    4. </servlet>  
    5. <servlet-mapping>  
    6.     <servlet-name>firstServlet</servlet-name>  
    7.     <url-pattern>/firstServlet</url-pattern>  
    8. </servlet-mapping>  

    上面的配置有几点需要说明:

    1、servlet里面的servlet-class节点需要填写servlet类的完整名称(包名.类名)

    2、servlet-mapping下的servlet-name节点的名称要与servlet下的servlet-name节点的名称一致,才能找到。

    3、url-pattern下的url要加"/"

    启动tomcat,在ie中输入localhost:8080/工程名/firstServet,即可浏览该页面(Get请求)。8080端口是tomcat默认设置的端口号,可以在tomcat/conf/下面的server.xml文件中修改端口号。比如我们修改了默认端口号为8088,重新启动tomcat(加载xml)以后,访问的url即为:localhost:8088/工程名/servlet映射的urlpattern名。


    展开全文
  • MYSQL数据库高级文档

    2018-06-05 10:33:22
    3:将相应的请求绑定到相应的控制器 4:根据控制器解析数据并返回相应的视图模型 5:根据spring配置解析方式并制定返回的路径 2:ajax(请求)就是能在jsp里面单独的发送请求给后台 3:json就是数据一种格式 4:...
  • 6.2 JSP数据库操作实例 6.3 Servlet数据库操作实例 6.4 JavaBeans操作数据库实例 6.5 三层结构开发数据库的优缺点 6.6 本章小结 第7章 综合开发实例分析 7.1 UML要点与应用 7.1.1 UML定义及组织 7.1.2 UML...
  • Flex4访问数据库文档

    2011-03-18 15:00:27
    的数据绑定到客户端应用程序中的用户界面组件。 例如,在 Flex 中,当用户在应用程序中单击 Button 控件时,客户端代码会调用 Web 服务。从 Web 服务中获得的结果数据 将返回到二进制 SWF 文件中,而无需刷新页面。...
  • 一、新手入行的搭建Spring MVC 框架 ...Dao与数据库打交道;Service写业务逻辑) 5、jsp页面调用el表达式 | 二、spring数据绑定 1、简单的数据类型绑定 地址栏请求的参数 2、使用"/“直接写参数方法 3、复

    一、新手入行的搭建Spring MVC 框架
    1、导入web 、webMvc.jar在这里插入图片描述
    2、配置web.xml文件中的servlet
    在这里插入图片描述
    3、创建配置文件XML文件
    在这里插入图片描述
    4、在引用时注意在Conttroller层,否则会有意想不到的惊喜,redirect重定向,forward转发(ps:Controller与前端交互;Dao与数据库打交道;Service写业务逻辑)
    在这里插入图片描述
    5、jsp页面调用el表达式
    在这里插入图片描述

    | 二、spring数据绑定
    1、简单的数据类型绑定
    在这里插入图片描述

    @RequestMapping("/save")
    public ModelAndView say(@RequestParam("n") String name,@RequestParam("a") Integer age) {
    	System.out.println(name);
    	System.out.println(age);
    	System.out.println("好嗨哟!controller");
    	//创建ModelAndView 对象,并指定转发的页面
    	ModelAndView model = new ModelAndView("/index.jsp");
    	//传递数据
    	model.addObject("msg", "lucky Yeah!");
    	//返回对象
    	return model ;
    }
    

    地址栏请求的参数在这里插入图片描述
    2、使用"/“直接写参数方法
    在这里插入图片描述
    在这里插入图片描述
    3、复杂的数据绑定——以对象的方式绑定
    @RequestMapping(“save”)
    public ModelAndView say(Student stu) {
    System.out.println(stu);
    stu.getId();//获取id的值
    stu.getName();
    stu.getStuNo();
    System.out.println(“好嗨哟!controller”);
    ModelAndView model = new ModelAndView(”/index.jsp");
    model.addObject(“msg”, “lucky Yeah!”);
    return model ;
    }
    创建一个Student对类,生成get\set方法,在上方say方法调用在这里插入图片描述
    请求路径:在这里插入图片描述
    4、无对象,map
    public ModelAndView say(@RequestParam Map<String , Object> data) {
    System.out.println(data);
    Object object = data.get(“name”);
    System.out.println(“好嗨哟!controller”);
    ModelAndView model = new ModelAndView("/index.jsp");
    model.addObject(“msg”, “lucky Yeah!”);
    return model ;
    }在这里插入图片描述
    5、批量删除,使用Arrays
    public ModelAndView say(String[] ids) {
    System.out.println(Arrays.toString(ids));
    System.out.println(“好嗨哟!controller”);
    ModelAndView model = new ModelAndView("/index.jsp");
    model.addObject(“msg”, “lucky Yeah!”);
    return model ;
    }
    名字相同 mlp在这里插入图片描述

    展开全文
  • MVC:Model View Controller Model: Dao +JavaBean View: Jsp Controller: Servlet Dao: 用于连接数据库及进行数据库的操作:增、删、改、查等 ...Servlet监听器:给web中的各种操作绑定事件,并对事件进行处理
  • 对于Web程序开发人员来说,如果要想把有用的信息从数据库中提取出来,传统的方法是在服务器端编写脚本程序(如VBScript、JavaScript、CGI、ASP、JSP,Perl等等),通过对数据库执行SQL查询得到相关记录,然后把查询...
    1、XML的局限性 
         目前,许多Web网站的内容数据都存放在数据库或数据文件中。对于Web程序开发人员来说,如果要想把有用的信息从数据库中提取出来,传统的方法是在服务器端编写脚本程序(如VBScript、JavaScript、CGI、ASP、JSP,Perl等等),通过对数据库执行SQL查询得到相关记录,然后把查询结果组织成HTML页面返回给客户端,用户使用浏览器观察最终结果。
    
         为了提高系统服务的灵活性、可扩展性,使服务对象范围更广,许多商业网站都尽可能地把商务规则、原始数据和表现形式当做相互独立的服务分别提供。HTML那种蕴数据于显示之中的方式显然不合乎这种需求。因此,把原始数据存放在XML文档中,使用样式单文件显示内容是XML技术适合于电子商务的优势所在。但从本质上来说,XSL技术不是面向数据显示的,它是一种格式转换技术,在显示手段和方式上都远不及HTML那样丰富。对编程人员来说,一种较为理想的方案是把HTML和XML两种技术相结合,优势互补,使真正的原始数据在能够保持本来意义和结构的同时,还能充分利用HTML那千变万化的显示技巧。XML数据岛就是这种技术融合的产物,它使用<XML>标签把XML数据直接嵌入到HTML页面中,从而实现了二者的优势互补。 
    
    2、IE中数据岛的处理方式 
    
         为了能够处理这种内嵌XML代码的HTML页面,Internet Explorer 4.0(以下简称IE 4.0)引入了DSO(Data Source Objects,数据源对象)技术,用Java Applet实现。 
    例如: 
    <APPLET CODE=“com.ms.xml.dso.XMLDSO.class” ID=“xmldso” WIDTH=0 HEIGHT=0 MAYSCRIPT=TRUE> 
    <PARAM NAME=“URL” VALUE=“myXML.xml”> 
    </APPLET> 
    
             上述例子中,CODE属性指明了DSO Java小程序,MAYSCRIPT属性保证用户端脚本能够处理数据对象,PARAM标签指明了XML文档的位置。
    
           使用Java的局限性在于只能在HTML文档中说明XML的URL地址,而不能直接将XML标签嵌入其中,这就和真正的数据岛方案还有一定的差距。微软在Internet Explorer 5.0(以下简称IE 5.0)中对DSO技术进行了扩展,突破了以往的限制,使HTML和XML真正地融合到了一起。HTML页面中支持直接使用<XML>标签。 
    
    例如: 
    <HTML> 
    <XML ID=“xmldso”> 
    <?xml version=“1.0”?> 
    some XML…… 
    </XML> 
    
          只要保证每个数据岛的ID都是唯一的,就可以在页面中的任何必要的地方嵌入数据岛,并且这些DSO彼此都是相互独立的。 
    
    除了上面例子中的这种直接嵌入方式,还可以使用外部引用方式链接数据岛。 
    例如: 
    <XML ID=“xmldso” SRC=“myXML.xml”> </XML> 
    
            这样,只有当公司的客户对象继续使用IE 4.0,并且为了解决这部分客户的兼容性问题时,Java Applet才是编程人员要考虑的选择方案。
    
            在IE 5.0所实现的DSO技术中,如果数据是通过SQL语言对数据库进行查询得到的结果,那么就把它们存放在ADO(ActiveX Data Objects)记录集中。服务器把这种ActiveX控件(通常是ADO记录集)发送到客户端,由客户端脚本程序做进一步的处理。实际上,IE 5.0就是把XML数据岛作为一种特殊的ADO记录集进行处理的。 
    
    3、XML的数据绑定
    (1)ADO记录集的映射
    XML中的每一条主元素都被映射为ADO记录集中的一条记录,而子元素则相应地被映射到记录集中的字段(也称为域)。 
    例如,存在XML数据岛books.xml如下: 
    <XML ID=“xmldso”> 
    <?xml version=“1.0”?> 
    <booklist> 
    <book> 
    <title>Straight Talk About Computers</title> 
    <isbn>72-80088-005</isbn> 
    </book> 
    <book> 
    <title> Gourmet Microwave </title> 
    <isbn>72-80081-082</isbn> 
    </book> 
    </booklist> 
    </XML> 
    此时,映射后的ADO记录集为: 
    title isbn 
    Straight Talk About Computers 72-80088-005 
    Gourmet Microwave 72-80081-082 
    
    (2)与HTML元素的绑定 
    
          在HTML文档中嵌入数据岛之后,就可以将XML数据岛与HTML元素绑定在一起。每一个DSO条目(即数据岛)都有唯一的ID号。首先将HTML元素中的datasrc属性设置为相应的ID,就可以把HTML元素和数据岛联系在一起。然后再通过设置datafld属性值,来确定所提取的XML元素。 
    
    例如,与DIV元素绑定的代码如下: 
    <DIV ID=title DATASRC=#xmldso DATAFLD=“title”></DIV> 
    <DIV ID=price DATASRC=#xmldso DATAFLD=“isbn”></DIV> 
    
          注意:并非所有的HTML元素都能与XML数据岛绑定。目前,支持这种DSO绑定机制的元素如下: 
    a、applet、button、div、frame、iframe、img、input (此处类型是:checkbox、hidden、label、password,radio,text)、label、marquee、select、span、table和textarea。 
    
    (3)以表格方式显式XML数据
    
    若把XML数据与TABLE元素绑定在一起,就可以自动地显示为多行的表格形式。 
    例如,XML数据与TABLE元素绑定的代码如下: 
    <TABLE BORDER=1 DATASRC=“#xmldso”> 
    <THEAD> 
    <TR>
    <TH>Title</TH> 
    <TH>ISBN</TH>
    </TR> 
    </THEAD> 
    <TBODY> 
    <TR><TD><DIV DATAFLD=“title”></DIV></TD> 
    <TD><DIV DATAFLD=“isbn”> </DIV></TD>
    </TR> 
    </TBODY> 
    </TABLE> 
    
    这样,通过将TABLE元素中的DATASRC属性设定为#xmldso,把两者绑定起来。表格内部分为表头(THEAD)和表体(TBODY)两部分。每一个<book>元素都会显示为一行表格,具体每一栏显示哪一项数据,则由DIV元素中的DATAFLD属性指定。 
    
    1、XML的嵌套处理
    
           一般情况下,我们从数据库中查询得到的结果集可能很大,所以从服务器返回到客户端时,数据会被分成若干个页面分别进行传递。此时,利用TABLE元素中的datapagesize属性可以指定每个页面包含记录集条目的个数。 
    例如: 
    <TABLE DATASRC=“#xmldso” datapagesize=10> 
    
          很显然,如果XML数据格式是对称的,则无论是映射到ADO记录集还是绑定到表格元素上,效果都会很好。而在实际应用中,XML数据为非对称的例子也很多,比如一本书的作者可能就不止一位,这在映射和绑定时都会产生一定的麻烦。
    
           解决问题的办法就是利用嵌套。每一行表格仍对应一条主元素,每一栏也对应着一个子元素。对于重复元素,则使用嵌套的表格。我们假设在books.xml中,第一本书的作者为Dean Straight,第二本书的作者为Charlotte Cooper、Shelley Burke和Regina Murphy。此时,绑定过程如下: 
    
    ● 创建TABLE元素,并将数据岛ID赋值给DATAFLD属性; 
    ● 对于单独的XML元素,如<isbn>,创建TD元素,并设定相应的DATAFLD属性; 
    ● 对于重复元素,在TD元素内部嵌套一个表格; 
    ● 用单行单列的形式显示作者信息。 
    注意这里的DATAFLD属性必须设定为“$TEXT”,
    以保证嵌套元素的内容被全部显示在指定的元素中。 
    完整的HTML代码如下所示: 
    <TABLE BORDER=1 DATASRC=“#xmldso”> 
    <THEAD>
    <TR>
    <TH>Title</TH> 
    <TH>ISBN</TH> 
    <TH>Author</TH>
    </TR>
    </THEAD> 
    <TBODY> 
    <TR>
    <TD> 
    <DIV DATAFLD=“title”></DIV></TD> 
    <TD><DIV DATAFLD=“isbn”></DIV></TD> 
    <TD> 
          <TABLE BORDER=0 DATASRC=“#xmldso” DATAFLD=“author”> 
              <TR><TD><SPAN datafld=“$Text”></SPAN></TD></TR> 
          </TABLE> 
    </TD> 
    </TR>
    </TBODY> 
    </TABLE> 
    
    事实上,使用DSO效果最好的情况是针对结构对称的数据,而处理非对称数据更有效的办法是使用我们以后将要介绍的DOM技术。 
    
    2、DSO技术的应用 
    1.访问元素的属性
    用DSO访问元素的属性很简单,可以直接把属性按子元素来处理。 
    例如: 
    <book isbn=“9-001-122-12”> 
    …… 
    </book> 
    这样,在绑定到HTML表格中时,就可以直接按子元素来处理: 
    <TD><SPAN DATAFLD=“isbn”> </SPAN></TD> 
    如果遇到属性名和子元素名一样的情况,在元素名前加上“!”进行区分。 
    
    2.遍历记录集 
           DSO把XML数据岛当做ADO记录集进行处理的一大好处是可以利用ADO提供的各种方法对数据源进行访问,尤其是当把数据岛与类似span、div和input等HTML元素绑定时。通常这些元素显示的是记录集的首条记录,要想对记录集进行遍历浏览,可以使用ADO的方法 : Move、MoveFirst、MoveLast、MoveNext和MovePrevious。比如创建一个按钮响应函数,只要用户点击“Next”按钮,就可以逐条浏览相应的记录。
    例如: 
    <XML ID=“xmldso” SRC=“books.xml”> 
    </XML> 
    Sub btnNext_onclick() 
    xmldso.RecordSet.MoveNext
    End Sub 
    
    3.与Script语言相结合 
           有些用户比较习惯编写Script语言,利用DSO技术同样可以与各种Script很好地结合在一起。 
    例如(以VB Script为例),访问记录集时,代码如下:  
    Dim rsBooks 
    Set rsBooks = xmldso.RecordSet 
    访问字段(子元素)的值: 
    Dim sTitle 
    sTitle = rsBooks(“title”) 
    可以使用innerText和innerHTML属性把得到的值传递给HTML元素。例如,有一个DIV元素名为divTitle,赋值代码如下所示: 
    divTitle.innerTEXT = sTitle 
    利用脚本程序还可以处理许多DSO事件,下表列举了其中的一部分事件:
    
         事件                                      触发事件                                            响应 
    onDataAvailable            新数据准备就绪                                     当前运行状态中记录集中条目的个数 
    onDataSetComplete       数据源中的所有数据已经到达               显示数据,或返回一个确认消息 
    onDataSetChanged      记录集中的数据修改完毕,                  可以访问 显示更新后的数据 
    onRowEnter                  当前记录指针已经移动                         在显示数据前对数据进行必要的格式化
    
    在脚本中处理各种事件的方法就是在<SCRIPT>标签中使用FOR属性指定XML数据岛ID,使用EVENT属性确定事件类型。 
    例如,获取记录集中条目的个数: 
    <SCRIPT Language=“VB Script” FOR=“xmldso” EVENT=“onDataAvailable”> 
    lblRecords.value = booklist.RecordSet.RecordCount 
    </SCRIPT> 
    
                  除了显示记录数据之外,脚本程序还可以对记录集进行快速查询、排序、编辑等操作。但要指出的是,虽然ADO技术中提供了类似SortColumn和SortAscending等方法对XML数据进行排序,但是效果不如XSL中的排序操作,所以建议大家充分利用XSL技术来实现这部分功能。 
    
    
             其余的功能,如利用脚本对记录集进行诸如增加、删除、修改等操作,或是分页显示HTML表格等等,在这里就不一一举例说明了,用法与前面的操作大同小异。最后需要说明的是,所有对DSO对象的操作都是在用户端完成的,实际上是服务器数据对象的一份复制品,这样做的好处是避免了网络承受大量数据通信的负担。但这时用户端所做的任何操作对服务器上存储的数据毫无影响,如果要想对服务器记录也进行修改,那么就要用到客户端与服务器端的数据交换技术,我们将在以后对此进行介绍
    

      

    转载于:https://www.cnblogs.com/ruishuang208/p/3819471.html

    展开全文
  • 表现层:WEB层,用来和客户端进行数据交互的。表现层一般会采用MVC的设计模型 业务层:处理公司具体的业务逻辑的 持久层:用来操作数据库的 表现层什么功能? 主要和浏览器进行数据的交互 浏览器向表现层发送请求...

    服务器端分成三层框架

    在这里插入图片描述

    三层架构

    1. 表现层:WEB层,用来和客户端进行数据交互的。表现层一般会采用MVC的设计模型
    2. 业务层:处理公司具体的业务逻辑的
    3. 持久层:用来操作数据库的

    表现层什么功能?

    主要和浏览器进行数据的交互
    浏览器向表现层发送请求参数
    表现层向浏览器相应结果

    MVC模型(属于表现层)

    M model 模型 JavaBean的一个对象
    V View 视图 JSP
    C Controller 控制器 Servlet ,用来接收用户的请求,整个流程的控制器。用来进行数据校验等。

    SpringMVC(表现层框架)在三层架构的位置
    SpringMVC在三层架构的位置

    在这里插入图片描述

    入门程序之需求分析

    在这里插入图片描述
    1 搭建开发的环境
    2 编写入门的程序

    1 搭建开发的环境

    创建maven骨架图
    在这里插入图片描述
    解决maven创建过慢
    在这里插入图片描述
    加入键值对
    archetypeCatalog
    internal

    在main目录下新建Java resource把目录结构补全并设为根目录和资源目录
    在这里插入图片描述

    导入坐标 依赖

    <spring.version>5.0.2.RELEASE</spring.version>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
    </dependency>
    <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
    </dependency>
    <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.0</version>
    <scope>provided</scope>
    </dependency>
    

    配置前端控制器
    在webapp中web.xml配置

    <web-app>
      <display-name>Archetype Created Web Application</display-name>
      <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      </servlet>
    
      <!--任何请求都会拦截-->
      <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    </web-app>
    

    创建配置文件
    在这里插入图片描述

    部署在Tomcat上
    在这里插入图片描述

    2 编写入门的程序

    编写首页

    index.jsp
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <h3>菜鸡</h3>
        <a href="hello">入门程序</a>
    </body>
    </html>
    

    实现点击链接后进入到控制器类并执行控制器类中的方法,要执行方法,必须有控制器的对象
    所以在HelloController 类上加上注解@Controller,可以交给SpringIOC容器进行管理
    接着在springmvc.xml中配置,扫描注解

    <!--先开启注解扫描,导入Context命名空间,在HelloController上加注解-->
    <context:component-scan base-package="cn.tju"></context:component-scan>
    

    需要执行方法,所以要给方法加上 @RequestMapping(path="/hello")注解
    意思是:加注解(请求-映射注解)后,相应的请求对应的方法就执行,可以设置请求的路径
    注意方法返回值是字符串,在springmvc框架中默认是Jsp文件的名字,所以此方法会返回succsee.jsp
    此时需要到springmvc.xml中继续配置

    <!--在方法一返回success,就去配置目录,找对应配置的后缀名文件-->
        <!--配置视图的解析器对象-->
        <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <!--文件所在的目录-->
            <property name="prefix" value="/WEB-INF/pages/"/>
            <!--文件的后缀名-->
            <property name="suffix" value=".jsp"></property>
        </bean>
    最后一定要开启注解的支持
     <!--开启springMVC框架注解的支持-->
        <mvc:annotation-driven/>
    

    HelloController.java

    @Controller
    public class HelloController {
    
        @RequestMapping(path="/hello")
        public String sayHello(){
            System.out.println("hello springMvc");
            return "success";
        };
    
    
    }
    

    springmvc.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
    
        <!--先开启注解扫描,导入Context命名空间,在HelloController上加注解-->
        <context:component-scan base-package="cn.tju"></context:component-scan>
    
    
        <!--在方法一返回success,就去配置目录,找对应配置的后缀名文件-->
        <!--配置视图的解析器对象-->
        <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <!--文件所在的目录-->
            <property name="prefix" value="/WEB-INF/pages/"/>
            <!--文件的后缀名-->
            <property name="suffix" value=".jsp"></property>
        </bean>
    
        <!--开启springMVC框架注解的支持-->
        <mvc:annotation-driven/>
    
    </beans>
    

    此时有一个问题就是配置文件(springmvc.xml)springmvc没法读取这个配置文件
    需要配置web.xml

    <!DOCTYPE web-app PUBLIC
     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    
    <web-app>
      <display-name>Archetype Created Web Application</display-name>
      <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--加载配置文件,创建容器,读取注解-->
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!--启动服务器就创建-->
        <load-on-startup>1</load-on-startup>
      </servlet>
    
      <!--任何请求都会拦截-->
      <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    </web-app>
    

    入门流程总结

    1 启动服务器,加载一些配置文件

    原来发送请求才创建servlet
    现在服务器已启动就创建servlet(dispatcherServlet)对象

     <!--启动服务器就创建-->
    <load-on-startup>1</load-on-startup>
    servlet对象一创建就加载类路径下的配置信息(springmvc.xml)
    <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    

    配置信息配了哪些信息?
    注解扫描,把类变创建成对象

    <!--先开启注解扫描,导入Context命名空间,在HelloController上加注解-->
        <context:component-scan base-package="cn.tju"></context:component-scan>
    

    创建注解解析器对象

     <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    

    整体注解生效开启

     <!--开启springMVC框架注解的支持-->
        <mvc:annotation-driven/>
    

    2 发送请求,后台处理请求

    通过index.jsp中的超链接发请求

    <a href="hello">入门程序</a>
    

    在web.xml中
    servlet(dispatcherServlet)拦截所有的请求
    dispatcherServlet前端控制器,指挥的中心,找到对应注解配置路径的方法
    方法执行完,控制台看到输出,返回“success”,前端控制器知道了返回“success”
    dispatcherServlet前端控制器找视图解析器对象InternalResourceViewResolver,通过其中配置的位置,和后缀名,找到success.jsp返回给servlet
    servlet显示页面,返回结果

    在这里插入图片描述

    入门案例中使用的组件介绍

    springmvc执行流程原理图
    在这里插入图片描述

    springmvc这个框架基于组件方式执行流程

    1 客户端发送一个请求,请求先到DispatcherServlet前端控制器(指挥中心)
    2 然后找处理器映射器HandlerMapping :作用,通过请求路径找到Controller类中对应的方法返回

    比如以上例子,前端请求路径<a href="hello">,在方法上配置注解@RequestMapping(path="/hello")
    HandlerMapping就是通过请求找对应的类HelloController对应方法sayHello()返回
    3 向前端控制器返回对应的类的一个方法

    前端控制器不能执行,只是起到一个中转的作用
    4找处理器适配器 HandlerAdapter
    处理器是指对应类Controller的对应方法
    适配器对于任何类(任何Controller)最终都由适配器会执行对应的方法
    5由适配器执行最终的方法
    6 返回视图页面 “success”也就是success.jsp
    7 向前端控制器返回这个页面success.jsp
    8 前端控制器找视图解析器ViewResolver
    9 视图解析器实现跳转到jsp页面
    10 返回结果
    11 响应回去

    RequestMapping注解

    作用:是建立请求URL和处理方法之间的对应关系

    RequestMapping源码图
    在这里插入图片描述
    RequestMapping注解可以放到方法上,也可以放到类上

    放到方法上,之前的例子就是
    @RequestMapping(path="/hello")
    public String sayHello(){

    如果请求是,分为一级目录/二级目录
    /user/hello
    放到类上相当于一级目录

    eg
    index.jsp

    <a href="user/testRequestMapping">RequestMapping</a>
    

    HelloController.java,其中@RequestMapping("/user")同时放在方法上和类上

    @Controller
    @RequestMapping("/user")
    public class HelloController {
    
        /**
         * RequestMapping注解
         * @return
         */
        @RequestMapping(path="/testRequestMapping")
        public String testRequestMapping(){
            System.out.println("测试RequestMapping注解。。。。");
            return "success";
        }
    }
    

    RequestMapping注解的属性

    path value属性

    @AliasFor("path")
    String[] value() default {};
    
    	
    @AliasFor("value")
    String[] path() default {};
    

    因为属性上互为别名,所以path和value属性的作用是相同的,都是指映射的路径

    method 属性

    RequestMethod[] method() default {};
    

    指定可以接收什么的请求方式
    用一个RequestMethod数组赋值
    RequestMethod是一个枚举类

    public enum RequestMethod {
    
    	GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
    
    }
    

    eg

    @RequestMapping(path="/testRequestMapping",method={RequestMethod.POST} )
        public String testRequestMapping(){
            System.out.println("测试RequestMapping注解。。。。");
            return "success";
        }
    

    params 属性

    String[] params() default {};
    赋值于String数组
    用于指定限制请求参数的条件,它支持简单的表达式,要求参数的key和value必须和表达式配置的一摸一样

    指定请求必须传一个username属性的参数

     @RequestMapping(path="/testRequestMapping",params={"username"})
        public String testRequestMapping(){
            System.out.println("测试RequestMapping注解。。。。");
            return "success";
        }
    
    <a href="user/testRequestMapping?username=hha">RequestMapping</a>
    

    则可以跳转

    指定一组key和value

    @RequestMapping(path="/testRequestMapping",params={"username=heihei"})
        public String testRequestMapping(){
            System.out.println("测试RequestMapping注解。。。。");
            return "success";
        }
    
    <a href="user/testRequestMapping?username=heihei">RequestMapping</a>
    

    headers属性

    String[] headers() default {};
    用于指定限制请求消息头的条件,也就是说发送的请求中必须包含请求头

     @RequestMapping(path="/testRequestMapping",params={"username=heihei"},headers ={"Accept"})
        public String testRequestMapping(){
            System.out.println("测试RequestMapping注解。。。。");
            return "success";
        }
    

    请求头
    在这里插入图片描述

    请求参数的绑定

    客户端传请求的时候带有参数,作为服务器一定要拿到参数,这个过程叫做参数绑定

    1 绑定机制

    表单提交参数都是一组键值对
    username=hehe&password=123
    这组键值对传过来

    如果表单提交名称和方法参数是一模一样的话sayHello(String username,String password)
    mvc框架就自动的会把请求传的值赋值到参数上

    1. 表单提交的数据都是k=v格式的 username=haha&password=123
    2. SpringMVC的参数绑定过程是把表单提交的请求参数,作为控制器中方法的参数进行绑定的
    3. 要求:提交表单的name和参数的名称是相同的

    2 支持的数据类型

    1. 基本数据类型和字符串类型
    2. 实体类型(JavaBean)
    3. 集合数据类型(List、map集合等)

    例子
    param.jsp

    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    <%--请求参数的绑定--%>
    <a href="param/testParam?username=hehe">请求参数绑定</a>
    </body>
    </html>
    

    ParamController.java

    /**
     * 请求参数绑定
     */
    @Controller
    @RequestMapping("/param")
    public class ParamController {
        /**
         * 请求参数绑定入门
         * @return
         */
        @RequestMapping("testParam")
        public String testParam(String username){
            System.out.println("执行了。。。。");
            System.out.println(username);
            return "success";
        }
    }
    

    结果
    执行了。。。。
    hehe

    如果把参数封装到一个JavaBean中

    前端使用表单传值
    表单中的name属性应该和JavaBean中属性是一致的,因为springmvc会通过name找JavaBean的set方法,给JavaBean属性赋值

    <form action="param/saveAccount" method="post">
        姓名:<input type="text" name="username"/><br/>
        密码:<input type="text" name="password"/><br/>
        金额:<input type="text" name="money"/><br/>
        <input type="submit" value="提交">
    </form>
    </body>
    </html>
    

    封装的JavaBean实体类Account

    public class Account implements Serializable{
        private String username;
        private String password;
        private Double money;
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public Double getMoney() {
            return money;
        }
    
        public void setMoney(Double money) {
            this.money = money;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", money=" + money +
                    '}';
        }
    }
    

    后端的控制器

    /**
     * 请求参数绑定
     */
    @Controller
    @RequestMapping("/param")
    public class ParamController {
    
    
        /**
         * 请求参数把数据封装到JavaBean类中,提交的表单数据默认就封装到account对象中
         * @return
         */
        @RequestMapping("/saveAccount")
        public String saveAccount(Account account){
            System.out.println("执行了222。。。。");
            System.out.println(account);
            return "success";
        }
    }
    

    结果
    执行了222。。。。
    Account{username=‘hehe’, password=‘200’, money=1000.0}

    如果封装的实体类的属性有引用类型
    多了user属性

    public class Account implements Serializable{
        private String username;
        private String password;
        private Double money;
        private User user;
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public Double getMoney() {
            return money;
        }
    
        public void setMoney(Double money) {
            this.money = money;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", money=" + money +
                    ", user=" + user +
                    '}';
        }
    }
    
    public class User implements Serializable{
        private String uname;
        private  Integer age;
    
        public String getUname() {
            return uname;
        }
    
        public void setUname(String uname) {
            this.uname = uname;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "uname='" + uname + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    对于新添加的input的name此时和account里user类的属性一致

    <form action="param/saveAccount" method="post">
        姓名:<input type="text" name="username"/><br/>
        密码:<input type="text" name="password"/><br/>
        金额:<input type="text" name="money"/><br/>
        <%--name此时指account里user类的属性--%>
        用户姓名:<input type="text" name="user.uname"/><br/>
        用户年龄:<input type="text" name="user.age"/><br/>
        <input type="submit" value="提交">
    

    后端控制器

    @Controller
    @RequestMapping("/param")
    public class ParamController {
    
    
        /**
         * 请求参数把数据封装到JavaBean类中,提交的表单数据默认就封装到account对象中
         * @return
         */
        @RequestMapping("/saveAccount")
        public String saveAccount(Account account){
            System.out.println("执行了222。。。。");
            System.out.println(account);
            return "success";
        }
    }
    

    结果
    执行了222。。。。
    Account{username=‘111’, password=‘111’, money=11.0, user=User{uname=‘11’, age=111111}}

    配置解决中文乱码的过滤器

    只需要在web.xml中配置一个过滤器

    <web-app>
    ................
      <!--配置解决中文乱码的过滤器-->
      <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <!--初始化参数-->
        <init-param>
          <param-name>encoding</param-name>
          <param-value>UTF-8</param-value>
        </init-param>
      </filter>
      <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
    </web-app>
    

    请求参数绑定集合类型

    public class Account implements Serializable{
        private String username;
        private String password;
        private Double money;
     
    
        private List<User> list;
        private Map<String,User> map;
    
       .................
    }
    

    前端表单

    <%--把数据封装到Account类中,类中存在集合list和map--%>
    <form action="param/saveAccount" method="post">
    姓名:<input type="text" name="username"/><br/>
    密码:<input type="text" name="password"/><br/>
    金额:<input type="text" name="money"/><br/>
    
    <%--把这组数据存放到user对象里去,再把user对象存放到list中去--%>
    用户姓名:<input type="text" name="list[0].uname"/><br/>
    用户年龄:<input type="text" name="list[0].age"/><br/>
        <%--把这组数据存放到user对象里去,再把user对象存放到map中去--%>
        用户姓名:<input type="text" name="map['one'].uname"/><br/>
        用户年龄:<input type="text" name="map['one'].age"/><br/>
    <input type="submit" value="提交">
    

    后台控制器

      /**
         * 请求参数把数据封装到JavaBean类中,提交的表单数据默认就封装到account对象中
         * @return
         */
        @RequestMapping("/saveAccount")
        public String saveAccount(Account account){
            System.out.println("执行了222。。。。");
            System.out.println(account);
            return "success";
        }
    

    结果
    执行了222。。。。
    Account{username=‘hehe’, password=‘123’, money=200.0, list=[User{uname=‘ddd’, age=11}], map={one=User{uname=‘22’, age=111}}}

    自定义类型转化器演示异常

    页面提交的任何数据都是字符串类型,springMVC自动进行类型转换

    正常情况下User由Date属性

    public class User implements Serializable{
        private String uname;
        private  Integer age;
    
        private Date date;
    
    ......
    }
    

    前端页面

    <%--自定义类型转化器--%>
    <form action="param/saveUser" method="post">
    <%--把这组数据存放到参数user对象里去--%>
    用户姓名:<input type="text" name="uname"/><br/>
    用户年龄:<input type="text" name="age"/><br/>
    用户生日:<input type="text" name="date"/><br/>
    <input type="submit" value="提交">
    

    提交格式
    在这里插入图片描述

    后端控制器

      /**
         * 自定义类型转化器
         * @param user
         * @return
         */
        @RequestMapping("/saveUser")
        public String saveUser(User user){
            System.out.println("执行了33。。。。");
            System.out.println(user);
            return "success";
        }
    

    结果正常输出
    执行了33。。。。
    User{uname=‘hehe’, age=200, date=Mon Nov 20 00:00:00 CST 2000}

    错误日期格式
    在这里插入图片描述

    引入自动类型转换器
    1 定义一个类,实现Converter接口,该接口由两个泛型

    技巧:

    ctrl+N 搜索Converter接口
    ctrl + alt +B查看Converter接口的实现类

    /**
     * 把字符串转换成日期
     */
    public class StringToDateConverter implements Converter<String,Date> {
    
        /**
         *
         * @param source 传入进来的字符串的值
         * @return
         */
        @Nullable
        @Override
        public Date convert(String source) {
            //判断
            if(source == null){
                throw new RuntimeException("请您传入数据");
            }
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            //把字符串转换成日期
            try {
                return  df.parse(source);
            } catch (Exception e) {
               throw new RuntimeException("数据类型转换错误");
            }
    
        }
    }
    

    2 配置自定义类型转化器

    <!-- 注册自定义类型转换器 -->
    <bean id="conversionService"
    class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
    <set>
    <bean class="cn.tju.utils.StringToDateConverter"/>
    </set>
    </property>
    </bean>
    <!-- 开启Spring对MVC注解的支持 -->
    <mvc:annotation-driven conversion-service="conversionService"/>
    

    这样原来错误的日期格式后台就能获取了

    获取servlet原生API

    直接在控制器方法上加上参数就行

    前端

    <a href="param/testServlet">Servlet原生的API</a>
    

    后台

      @RequestMapping("/testServlet")
        public String testServlet(HttpServletRequest request, HttpServletResponse response){
            System.out.println("执行了44。。。。");
            System.out.println(request);
    
    
            HttpSession session = request.getSession();
            System.out.println(session);
    
            ServletContext servletContext = session.getServletContext();
            System.out.println(servletContext);
            System.out.println(response);
            return "success";
        }
    

    结果
    执行了44。。。。
    org.apache.catalina.connector.RequestFacade@2c7e3c0a
    org.apache.catalina.session.StandardSessionFacade@65aac915
    org.apache.catalina.core.ApplicationContextFacade@491e0652
    org.apache.catalina.connector.ResponseFacade@7b9d7c01

    常用注解

    1. RequestParam注解

    1. 作用:把请求中的指定名称的参数传递给控制器中的形参赋值
      解决,前端请求参数和后端控制器方法参数不一样封装不到数据的问题
    2. 属性
      • value:请求参数中的名称
      • required:请求参数中是否必须提供此参数,默认值是true,必须提供

    前端请求

    <a href="anno/testRequestParam?name=哈哈">RequestParam</a>
    

    name和方法参数username不匹配所以使用RequestParam注解
    后端控制器

    /**
     * 常用的注解
     */
    @Controller
    @RequestMapping("/anno")
    public class AnnoContrller {
    
        @RequestMapping("/testRequestParam")
        public String testRequestParam(@RequestParam(value ="name")  String username){
            System.out.println("执行了....");
            System.out.println(username);
            return "success";
        }
    }
    

    2. RequestBody注解

    1. 作用:用于获取请求体的内容,直接使用得到是key=value&key=value…结构的数据
      注意:get方法不可以,get方式是没有请求体,只有post请求有请求体

    2. 属性

      • required:是否必须有请求体,默认值是true

    前端

    <form action="anno/testRequestBody" method="post">
        用户姓名:<input type="text" name="username"/><br/>
        用户年龄:<input type="text" name="age"><br/>
        <input type="submit" value="提交"/>
    </form>
    

    后端

     /**
         * 获取到请求体的内容
         * @return
         */
        @RequestMapping("/testRequestBody")
        public String testRequestBody(@RequestBody String body){
            System.out.println("执行了。。。//");
            System.out.println(body);
    
            return "success";
        }
    

    结果
    执行了。。。//
    username=111&age=1

    3. PathVariable注解

    1. 作用:拥有绑定url中的占位符的。例如:url中有/delete/{id},{id}就是占位符

    2. 属性

      • value:指定url中的占位符名称
    3. Restful风格的URL

      • 请求路径一样,可以根据不同的请求方式去执行后台的不同方法
      • restful风格的URL优点
      • 结构清晰
      • 符合标准
      • 易于理解
      • 扩展方便

    原来方式

    UserController类
    @RequestMapping() 也就是path="/user/save"
    save方法
    @RequestMapping() 也就是path="/user/upDate"
    upDate方法
    @RequestMapping() 也就是path="/user/findAll"
    findAll方法

    restful方式

    不同的方法路径是同一个,发送请求地址都一样,但是根据请求方式不一样区分
    @RequestMapping() 也就是path="/user post
    save方法
    @RequestMapping() 也就是path="/user" put
    upDate方法
    @RequestMapping() 也就是path="/user" get
    findAll方法

    当发送localhost:8080/user get,虽然请求地址一样但是根据请求方式找到findAll方法

    如果还有一个相同请求方式的方法,通过占位符区分
    path="/user/{id}" get
    findById(id)

    发送 localhost:8080/user/10 get 找到findById(id)方法
    发送 localhost:8080/user 找到findAll方法

    例子

    前端
    <a href="anno/testPathVariable/10">RequestParam</a>
    后端
     /**
         * PathVariable注解
         * @param id
         * @return
         */
        @RequestMapping("/testPathVariable/{sid}")
        public String testPathVariable(@PathVariable(name="sid") String id){
            System.out.println("执行了。。。o ");
            System.out.println(id);
    
            return "success";
        }
    

    结果
    执行了。。。o
    10

    4 RequestHeader注解

    1. 作用:获取指定请求头的值
    2. 属性
      • value:请求头的名称
      • required:是否必须有此消息头

    前端

    <a href="anno/testRequestHeader">RequestHeader</a>
    

    后台

     @RequestMapping("/testRequestHeader")
        public String testRequestHeader(@RequestHeader(value = "Accept") String header){
            System.out.println("执行了。。。ob");
            System.out.println(header);
    
            return "success";
        }
    

    结果
    执行了。。。ob
    text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8

    5. CookieValue注解

    1. 作用:用于获取指定cookie的名称的值
    2. 属性
      • value:cookie的名称

    前端

    <a href="anno/testCookieValue">testCookieValue</a>
    后台
        @RequestMapping("/testCookieValue")
        public String testCookValue(@CookieValue(value ="JSESSIONID") String cookievalue){
            System.out.println("执行了。。。ob");
            System.out.println(cookievalue);
    
            return "success";
        }
    

    结果
    执行了。。。ob
    C79AABC03C307D8E95DCF3EBDDF9E3F0

    6. ModelAttribute注解

    1. 作用
      1. 出现在方法上:表示当前方法会在控制器方法执行前线执行。
      2. 出现在参数上:获取指定的数据给参数赋值。
    2. 应用场景
      1. 提交表单数据不是完整的实体数据时,保证没有提交的字段使用数据库原来的数据。

    1. 修饰的方法有返回值

    /**
    * 作用在方法,先执行
    * @param name
    * @return
    */
    @ModelAttribute
    public User showUser(String name) {
    System.out.println("showUser执行了...");
    // 模拟从数据库中查询对象
    User user = new User();
    user.setName("哈哈");
    user.setPassword("123");
    user.setMoney(100d);
    return user;
    }
    
    
    @RequestMapping(path="/updateUser")
    public String updateUser(User user) {
    System.out.println(user);
    return "success";
    }
    

    2. 修饰的方法没有返回值

    /**
    * 作用在方法,先执行
    * @param name
    * @return
    */
    @ModelAttribute
    public void showUser(String name,Map<String, User> map) {
    System.out.println("showUser执行了...");
    // 模拟从数据库中查询对象
    User user = new User();
    user.setName("哈哈");
    user.setPassword("123");
    user.setMoney(100d);
    map.put("abc", user);
    }
    /**
    * 修改用户的方法
    * @param cookieValue
    * @return
    */
    @RequestMapping(path="/updateUser")
    public String updateUser(@ModelAttribute(value="abc") User user) {
    System.out.println(user);
    return "success";
    }
    

    7 SessionAttributes注解

    1. 作用:用于多次执行控制器方法间的参数共享,多次请求Session对话还在,此注解作用在类上
    2. 属性
      1. value:指定存入属性的名称
    @Controller
    @RequestMapping(path="/user")
    @SessionAttributes(value= {"username","password","age"},types=
    {String.class,Integer.class}) // 把数据存入到session域对象中
    public class HelloController {
    /**
    * 向session中存入值
    * @return
    */
    @RequestMapping(path="/save")
    public String save(Model model) {
    System.out.println("向session域中保存数据");
    model.addAttribute("username", "root");
    model.addAttribute("password", "123");
    model.addAttribute("age", 20);
    return "success";
    }
    /**
    * 从session中获取值
    * @return
    */
    @RequestMapping(path="/find")
    public String find(ModelMap modelMap) {
    String username = (String) modelMap.get("username");
    String password = (String) modelMap.get("password");
    Integer age = (Integer) modelMap.get("age");
    System.out.println(username + " : "+password +" : "+age);
    return "success";
    }
    /**
    * 清除值
    * @return
    */
    @RequestMapping(path="/delete")
    public String delete(SessionStatus status) {
    status.setComplete();
    return "success";
    }
    }
    
    展开全文
  • 随后技术性强一点的网站可能会通过 <em>CGI Perl</em> 运行一小段代码与数据库或文件系统进行交互。比如: <p><img alt="" src="http://op0c7euw0.bkt.clouddn.com/15356327607072.jpg" /> 这是<em>1998</em> ...
  • 先说思路:jsp页面展示点线面的坐标,点,线,面,新增,修改,展示,给每个图形绑定左右键事件,都在一个页面上了.把数据放到数据库. 有几点要注意的: 1,在新增和修改坐标的时候因为用的是高德地图,所以获取的是高德坐标-...
  • -- 数据库访问控制依赖 --> <groupId>org.springframework.boot <artifactId>spring-boot-starter-jdbc <groupId>org.webjars <artifactId>bootstrap <version>4.4.1 <!-- ...
  • 书名:《Java Web开发实战1200例(第II卷)》(清华大学出版社.卢瀚.王春斌) PDF格式扫描版,全书分为7篇23章,共960页。2011年6月出版。 注:原书只有前20章818页,本人添加了剩余章节重新编辑成完整版本,为了方便...
  • 书名:《Java Web开发实战1200例(第II卷)》(清华大学出版社.卢瀚.王春斌) PDF格式扫描版,全书分为7篇23章,共960页。2011年6月出版。 注:原书只有前20章818页,本人添加了剩余章节重新编辑成完整版本,为了方便...
  • 书名:《Java Web开发实战1200例(第II卷)》(清华大学出版社.卢瀚.王春斌) PDF格式扫描版,全书分为7篇23章,共960页。2011年6月出版。 注:原书只有前20章818页,本人添加了剩余章节重新编辑成完整版本,为了方便...
  • Grails 技术精解与Web开发实践【源码+样章】----...20.4 在GSP中使用JSP的标签 246 20.5 加密配置文件中的数据库密码 246 20.6 本章小结 246 参考文献 247 索引 248 Grails技术精解与Web开发实践 目录 XII XI
  • ssm框架整合activiti流程,在控制器中使用注入有关activities的一些Service如:RepositoryService、ProcessEngine、TaskService、RuntimeService、HistoryService,运行web项目后报错,后面网上借鉴了一些activitie...
  • 通用分页

    2019-06-04 14:15:19
    搭建一个web项目,实现数据的完整绑定 1.1 创建数据库 1.2 创建动态web项目,并创建好相应包: web :—>Servlet dao 第一次查满足条件的总记录数 第二次查指定页码并满足条件的记录 二次查询的条件要一致 entity...
  • 互相对应的:1.jsp与servlet一起使用servlet—EmpServlet —@WebServlet(urlPatterns ={"/emplist"})获得数据 private EmpService empService = new EmpServiceImpl();重写 service①.查询数据库LIst empList = ...
  • JavaWeb实战开发

    千人学习 2019-05-01 11:40:14
    7.JSP访问数据库、JavaBean(封装数据和封装业务逻辑)      8.MVC模式与Servlet执行流程、Servlet25与Servlet30的使用、ServletAPI详解与源码分析      9.MVC案例、三层架构详解、乱码...
  • 为什么要有前端架构师

    千次阅读 2018-12-28 14:57:41
    前端工程师的诞生, 就源于 web 开发这个问题规模的膨胀, 早期的网络程序员, 和现在的全栈工程师具有类似的属性, 唯一的区别是处理问题的规模相差极大, 在使用 jsp, asp 编写网页的年代, web 开发在页面端需要处理的...
  • 这是用jsp做普通的增删改查的功能 前置任务: copy 驱动包sqljdbc4.jar 到WEB-INF/lib copy BaseDAO.java 到 dao 包中 根据数据库 写好实体类比如entity.Users 写一个跟实体类同名+DAO数据库访问类比如 dao.UsersDAO...
  • 2.通过编码实现页面与数据库进行数据绑定 3.书籍搜索详情后台实现,加入购物车前台页面,购物车功能 entity 1.加入购物车携带的数据字段 package com.houzhihong.vo; public class ShoppingVo { // 购物车列表...
  • 将属性与会话绑定 169 与会话相关联的通知对象 170 会话管理 170 会话跟踪 170 结束servlet 171 跟踪服务请求 171 通知方法Shut Down 172 创建长时间运行的方法 173 第11章 JSP技术 175 什么是JSP页面 175 JSP页面的...
  •  Spring3.0引入了众多Java开发者翘首以盼的新功能和新特性,如OXM、校验及格式化框架、REST风格的Web编程模型等。这些新功能实用性强、易用性高,可大幅降低Java应用,特别是JavaWeb应用开发的难度,同时有效提升...
  •  Spring3.0引入了众多Java开发者翘首以盼的新功能和新特性,如OXM、校验及格式化框架、REST风格的Web编程模型等。这些新功能实用性强、易用性高,可大幅降低Java应用,特别是JavaWeb应用开发的难度,同时有效提升...
  • 我们学习到了如何进行基本的dorado开发,然而其中并未涉及到Web项目的最大的根本,即数据的交互和页面中的数据展现。本书中从第5章至第8章,主要以HelloWorld示例进行四部分的示例讲解。在<展现>章节中主要讲解了...
  • java面试题

    2018-04-27 19:55:38
    5:Spring WEB:为基于WEB服务的应用程序提供上下文服务 6:Spring Context:向Spring框架提供上下文信息 7:Spring MVC:分离模型、视图、控制器、以便更容易定制 折构函数和虚函数? 答:折构函数式销毁一个类...

空空如也

空空如也

1 2 3 4 5 6
收藏数 107
精华内容 42
关键字:

webjsp绑定数据库