Teachmepatiently

JavaWeb

基于idea、狂神

JavaWeb
一、JavaWeb
- 4. 一个网站访问的过程：
二、Maven
- idea技巧之Ctrl+Shift+/快速添加注释
三、Servlet
- idea技巧之alt+fn+prt sc或alt+Ins在web.xml中快速插入和功能块
- idea技巧之快捷键alt+enter：先输入一个返回变量的方法名，或new一个类的对象，然后按快捷键可以补充该对象的声明语句
四、ServletContext
- 重要技巧之.properties文件
- classpath
五、HttpServletResponse（extends ServletResponse）
- 重定向和转发的区别
六、HttpServletRequest
七、会话
- 1. Cookie
- 2. Session
- idea技巧之 packege分包与取消分包的方式：
- idea技巧之快速自动生成getter、setter等方法，或在xml中快速生成servlet等代码块：alt+insert
八、JSP
- 1. 基本原理
- 2. 基础语法
- 3. JSP指令
- 4. 九大内置对象
- 5. JSP标签、JSTL标签、EL表达式
九、JavaBean
- 重要技巧之Lombok
十、MVC三层架构
- 架构思想：
十一、Filter（重点）
- idea技巧之快速添加web框架支持：
十二、监听器
十三、过滤器、监听器常见应用
- 重要技巧之静态static变量的使用:
十四、回顾JDBC
- idea技巧之快速键入main()方法的声明
- idea技巧之快速键入“System.out.println()”
- 重要技巧之junit单元测试可以对某个方法单独运行而无需main()方法：
十五、Ajax
十六、项目搭建实战（超市订单管理系统SMBMS）
- 1、准备工作
- 功能实现阶段——先画出功能的MVC三层架构，再从底向上逐层实现功能：
- 2、登录功能实现
- - View层
  - Modle层
  - - DAO层
- idea技巧之快速键入某个参数的非空判断语句和@NotNull插件
- - - service层
- 重要技巧之方便地对底层属性和方法进行调用
- - Controller/Servlet层
- 3. 登录功能优化
- 4. 密码修改功能实现
- - View层
  - Model层
  - - DAO层
    - Service层
  - Controller/Servlet层
- 重要技巧之Servlet复用
- 5. 密码修改功能优化（Ajax）
- 6. 用户管理功能实现
- - View层
  - Modle层
  - - DAO层
    - Service层
  - Controller/Servlet层
十七、文件上传
十八、邮件发送原理和实现

一、JavaWeb

静态web
页面无法更新，所有用户看到的都是同一个页面。
静态资源：html、css等
客户端给服务器发送请求，web server接受请求，将静态资源发送给客户端作为响应。
动态web
页面动态展示，web的页面因人而异。
技术栈：JSP/Servlet（B/S架构（浏览器和服务器）、基于Java语言（大多数公司的组件都是Java））、ASP、PHP
客户端给服务器发送请求，web server plugin接受请求，将file system中的静态资源和JSP或Servlet中的动态资源通过web server作为响应发还。
web服务器（web server）Tomcat
最适合的一种：Tomcat（基于Java）
安装Tomcat：

启动Tomcat:

访问测试：浏览器访问路径“localhost:8080”
配置Tomcat：

默认端口号：Tomcat——8080；http——80；https——443

默认主机名称：localhost（127.0.0.1）
默认网站应用存放位置：webapps

4. 一个网站访问的过程：

Created with Raphaël 2.3.0 输入一个域名检查本机的 C:\Windows\System32\drivers\etc\hosts 配置文件下有没有这个域名映射访问去DNS服务器里找，全世界的域名都在这管理返回：找不到 yes no yes no

发布一个web网站
将网站源代码放到服务器（tomcat）中指定的web应用的文件夹（webapps）下，就可以访问了：

访问域名：localhost:8080/y_study
在IDEA中配置Tomcat
下一章介绍

二、Maven

下载Maven
1.Maven官网，点击左边download
2.下载所需版本的bin.zip并解压
注意：所选maven版本的发布日期最好早于idea的

3.配置环境变量：
系统变量新建M2_HOME

新建MAVEN_HOME

编辑Path变量，增加如下：

在cmd中输入mvn -version可查看配置情况
4.修改配置文件
搜索maven镜像，得到配置内容：

编辑apache-maven-3.8.3\conf中的settings.xml，将这段镜像内容粘贴进去，具体位置：

5.建立本地仓库
在apache-maven-3.8.3中新建一个maven-repo文件夹，得到该文件夹的地址，并在settings.xml中增加这一行内容：

<localRepository>F:\IJ IDEA\maven\apache-maven-3.8.3-bin\apache-maven-3.8.3\maven-repolocalRepository>

在IDEA（以下皆需专业版）中创建一个Maven项目
1.启动idea，创建一个maven项目。可以勾选create from archetype，在下方选择Maven模板，这里选择maven的webapp，可创建一个webapp模板

或者，不创建模板

之后，

2.配置maven的家路径、setting.xml路径和本地仓库（maven-repo文件夹）路径，新建项目时可以配置，也可以在Settings中配置。在等待包数据下载好以后可在本地仓库中看到下载的包

注意，此时的配置只能对这一项目生效，换一个项目就需要重新配置，如需全局配置，则需关闭project后在初始页面配置，如下：

认识maven
一个干净的（普通的）maven项目，即没有创建模板：

有webapp的maven项目：

将maven的结构构建完整
在main文件夹下创建一个java文件夹（directory）和一个resources文件夹，创建时会有快捷创建提示。若没有，则创建好后右键点击java文件夹，点击Mark Directory as，选择文件夹类型

或者在Fire中的项目结构中进行配置

5. 在IDEA中配置Tomcat
1.

warning出现原因：访问一个网站时，必须指定一个文件夹的名字
解决办法：添加一个项目文件夹

创建一个war包，下面的是war导出包

应用上下文决定默认访问地址，若为“/”，则默认访问路径为localhost:8080
若为“/y”，则默认访问路径为localhost:8080/y/

配置完成，运行该Tomcat（点击运行键），等待之后弹出以下网站，“Hello World！”是默认的webapp目录中index.jsp中的内容，这是因为index.jsp是默认的访问对象

将maven中的webapp版本替换为与tomcat中的一致
将maven项目中src\main\webapps\ROOT\WEB-INF\web.xml中的内容替换为
apache-tomcat-9.0.54-windows-x64\apache-tomcat-9.0.54\webapps\ROOT\WEB-INF\web.xml的内容
分析pom文件




<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">

	<modelVersion>4.0.0modelVersion>
	

	<groupId>com.ygroupId>
	<artifactId>javaweb03-mavenartifactId>
	<version>1.0-SNAPSHOTversion>
	
	
	<packaging>warpackaging>

	<name>javaweb03-maven Maven Webappname>
	
	
	<url>http://www.example.comurl>
	
	
	-<properties>
	
		
		<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
		
		
		<maven.compiler.source>1.7maven.compiler.source>
		<maven.compiler.target>1.7maven.compiler.target>
		
	properties>
	
	
	<dependencies>
	
		
		<dependency>
			<groupId>junitgroupId>
			<artifactId>junitartifactId>
			<version>4.11version>
			<scope>testscope>
		dependency>
		
		
		<dependency>
			<groupId>javax.servletgroupId>
			<artifactId>javax.servlet-apiartifactId>
			<version>4.0.1version>
		dependency>
		
			
		<dependency>
			<groupId>javax.servlet.jspgroupId>
			<artifactId>javax.servlet.jsp-apiartifactId>
			<version>2.3.3version>
		dependency>
	
	dependencies>

	
	<build>
		<finalName>javaweb03-mavenfinalName>
		<pluginManagement>
			
			<plugins>
				<plugin>
					<artifactId>maven-clean-pluginartifactId>
					<version>3.1.0version>
				plugin>
				
				<plugin>
					<artifactId>maven-resources-pluginartifactId>
					<version>3.0.2version>
				plugin>
				<plugin>
					<artifactId>maven-compiler-pluginartifactId>
					<version>3.8.0version>
				plugin>
				<plugin>
					<artifactId>maven-surefire-pluginartifactId>
					<version>2.22.1version>
				plugin>
				<plugin>
					<artifactId>maven-war-pluginartifactId>
					<version>3.2.2version>
				plugin>
				<plugin>
					<artifactId>maven-install-pluginartifactId>
					<version>2.5.2version>
				plugin>
				<plugin>
					<artifactId>maven-deploy-pluginartifactId>
					<version>2.8.2version>
				plugin>
			plugins>
		pluginManagement>
	build>
project>


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <groupId>com.ygroupId>
    <artifactId>javaweb01.mavenartifactId>
    <version>1.0-SNAPSHOTversion>

    <properties...>

    <dependencies>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.11version>
            <scope>testscope>
        dependency>
        
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.3.10version>
        dependency>
    dependencies>

    
    <build>
        <resources>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.propertiesinclude>
                    <include>**/*.xmlinclude>
                includes>
                <filtering>falsefiltering>
            resource>
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.propertiesinclude>
                    <include>**/*.xmlinclude>
                includes>
                <filtering>falsefiltering>
            resource>
        resources>
    build>
project>

idea技巧之Ctrl+Shift+/快速添加注释

查看IDEA项目中的jar包与其中的联系

三、Servlet

Servlet原理步骤
浏览器给web浏览器发送http请求
Web浏览器把请求req/request交给HttpServlet类中的
service(ServletRequest req, ServletResponse res)
该方法通过调用我们编写的实现类中覆盖的方法，如
doGet(HttpServletRequest req, HttpServletResponse resp)等，给出响应res/resp/response信息
web服务器将这些信息相应给客户端浏览器
学习模板
启动Tomcat（见一、3.web服务器（web server）Tomcat）后，在浏览器中访问http://localhost:8080/examples/，进入Servlets examples，点击Code就可以查看各Servlet源代码。
写Servlet（以模仿HelloWorld Example为例）
1.创建一个maven项目（见maven笔记），并进行Maven环境优化
1.1.将web.xml修改成最新版：


<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">
web-app>

1.2.将maven的结构构建完整（见二、4.）

2.在maven项目的src\main\java中新建一个package，包名为你想要的web域名，然后在这个package中新建class，或者直接在java中新建一个class

3.Maven仓库的使用：下载jar包（方法一：在mvn官网中搜索寻找所需要的包）：

模板：


<dependency>
    <groupId>javax.servletgroupId>
    <artifactId>javax.servlet-apiartifactId>
    <version>4.0.1version>
    <scope>providedscope>
dependency>


<dependency>
    <groupId>javax.servlet.jspgroupId>
    <artifactId>javax.servlet.jsp-apiartifactId>
    <version>2.3.3version>
    <scope>providedscope>
dependency>

依然复制到pom.xml中，刷新
删除作用域，则在所有情况下都能使用

方法二：点击mvn网站中所需包的“jar”按钮直接下载jar包，然后拷贝到maven仓库中javax文件夹的相应文件夹中）

4.编写一个servlet的java程序
直接继承HttpServlet ，并import导入包：

查看HttpServlet源码（快捷键Ctrl+鼠标左键点击一个对象（类、方法、变量等）可查看其源码），发现servlet的各接口/抽象类之间的关系为

注意，servlet在sun公司有两个默认的实现类：HttpServlet、GenericServlet

5.覆盖HttpServlet类中的doGet和doPost方法（快捷键Ctrl+O可以选择要定义或覆盖的父类方法）

可以直接将HelloWorld Example中的doGet的方法体复制过来：

如果要在页面中显示中文，则加上编码方式：

doGet方法中：
指定响应类型为html：resp.setContentType(“text/html”)。注意，一个页面的相应类型可以通过以下方式查看：右键点击页面–>检查–>

必须定义一个响应流：PrintWriter writer = resp.getWriter()
在页面中显示内容：writer.print(“hello,servlet”)。注意，这里的writer是前面定义的响应流对象

doPost方法中：
由于get或post只是请求实现的不同方式，业务逻辑都一样，因此可以相互调用：doGet(req, resp)；也可以直接继承父类的。

6.注册servlet：由于浏览器访问的是web服务器，因此我们写的servlet需要在web服务器中注册，并且因为web.xml是web配置的核心应用，所以注册的方式就是改写这个文件，包括添加servlet的映射，映射中包含有其访问路径。
具体方法及注释：

idea技巧之alt+fn+prt sc或alt+Ins在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 Applicationdisplay-name>

  
  <servlet>
    
    <servlet-name>helloServletservlet-name>
    
    <servlet-class>com.y.servlet.HelloServletservlet-class>
  servlet>

  
  <servlet-mapping>
    <servlet-name>helloServletservlet-name>
    
    <url-pattern>/yurl-pattern>
  servlet-mapping>

  
  <servlet-mapping>
    <servlet-name>helloServletservlet-name>
    <url-pattern>/y1url-pattern>
  servlet-mapping>
web-app>

其中的访问路径还可以通过使用通配符“* ”来指定通用路径：
方法一：

访问路径为：默认路径+/hello/+任意
方法二：通用路径直接设为“/* ”，只是默认访问对象不再是index.jsp，而是指定的servlet对象
方法三：自定义后缀，但* 前不能加任何路径。例如：“*.ycr“, 默认访问对象仍然是index.jsp，访问路径为任何“默认路径+任意+.ycr”都可以访问servlet，并且默认访问对象仍然是index.jsp；“/hello/ *.ycr“，错误。
通用路径的优先级问题：指定了固有的映射路径优先级最高，找不到才会走通用路径

7.编写完成后，配置tomcat（见maven笔记），主要配置项目发布的路径即可

8.访问：直接运行，或启动tomcat（见tomcat笔记）。使用“默认地址+为该servlet注册时其name对应映射的请求路径”。以上面这个servlet为例：

在servlet中新建一个静态web
1.编写：在webapp中新建一个HTML文件，即可编写页面内容。例如：
浏览：在默认访问地址后添加“该HTML文件名.html”即可访问。例如：
总结与技巧
1.写一个Servlet程序只需要两个步骤:
1.1.编写一个类，实现Servlet接口；
1.2.把开发好的java类部署到web服务器中

2.学习可以在一个项目(比如javaweb04-servlet)里面建立module(比如servlet-01)，而这个空的项目就是maven主工程：新建maven项目时，删掉src目录，在该项目中创建一个module，这里与创建一个带有webapp的maven项目的步骤相同。该module与maven主工程是maven父子工程，此时父项目中的pom.xml会有：

    <modules>
        <module>servlet-01module>
    modules>

子项目中的会有（没有就手写）：

  <parent>
    <artifactId>javaweb04-servletartifactId>
    <groupId>com.ygroupId>
    <version>1.0-SNAPSHOTversion>
  parent>

注意：module中的pom若没有上面这一段指出父项目，则无法继承其资源，比如无法导入其jar包

子项目可以extends父项目，好处是子项目不需要再手动导入父项目中已经导入的资源

idea技巧之快捷键alt+enter：先输入一个返回变量的方法名，或new一个类的对象，然后按快捷键可以补充该对象的声明语句

四、ServletContext

Web容器在启动的时候，它会为每个web程序创建一个对应的ServletContext对象，它代表了当前的web应用。

功能：

共享不同servlet的数据。这样在一个服务器中放入数据后在另一个服务器中也可以使用。

ServletContext的初始化和调用、context.setAttribute和context.getAttribute：

public class helloservlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //this.getServletConfig(); Servlet配置
        ServletContext context = this.getServletContext();//初始化一个Servlet上下文
        String username="应";//数据
        context.setAttribute("username",username);
        //将一个数据保存在了ServletContext中，名字为username（前者），值为username“后者”
        
        System.out.println("hello");
    }
}

public class getServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();//获取servlet上下文
        String username=(String)context.getAttribute("username");
        //取到context中的名为username（后者）的数据，帮将它赋值给username（前者）。getAttribute()方法返回的是object对象，可以强转成String
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("名字"+username);
    }
}

servlet注册略
测试方法：先启动helloservlet，再启动getServlet
测试结果：后台显示“hello”，getServlet显示“应”

获取初始化参数
context.getInitParameter(“url”)：
web.xml:

  
  <context-param>
    <param-name>urlparam-name>
    <param-value>jdbc:mysql://localhost:3306/mybatisparam-value>
  context-param>

public class servletdemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String url = context.getInitParameter("url");//获取初始化参数
        resp.getWriter().print(url);
    }

测试结果：servletdemo03显示“jdbc:mysql://localhost:3306/mybatis”

请求转发（在一个servlet上运行另一个servlet）
context.getRequestDispatcher(“”).forward(req,resp)：

在servletdemo03的基础上（/gp为servletdemo03的url地址），

public class servletdemo04 extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp");//转发的请求路径
        requestDispatcher.forward(req,resp);//调用forward实现请求转发
        //或者直接：context.getRequestDispatcher("/gp").forward(req,resp);

        System.out.println("进入了s4");
    }

测试结果：servletdemo04显示“jdbc:mysql://localhost:3306/mybatis”

读取资源文件（.properties文件）
properties文件、context.getServletContext().getResourceAsStream()、properties.load()和properties.getProperty()

第一步：在java目录下或者在resources目录下新建properties文件
第二步：可以编写properties文件内容为：

username=root
password=123456

第三步：

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream is= this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        //获取context中的资源流
        Properties prop= new Properties();//初始化一个properties对象
        prop.load(is);//将获取的资源流加载到该properties对象中
        String user= prop.getProperty("username");
        String pwd= prop.getProperty("password");//获取properties中的名为“username”和“password”的资源内容
        resp.getWriter().print(user+":"+pwd);
    }

重要技巧之.properties文件

classpath

如果要获取的properties文件在resources目录下，则无需修改pom文件；
如果要获取的properties文件在java目录下，则需在pom中的build中配置resources，来防止我们资源导出失败的问题，配置内容见本文二、Maven 7.分析pom文件的第二块代码。此时获取资源流时寻找properties导出文件的路径变为了"/WEB-INF/classes/com/y/db.properties"，这里/com/y指代的是target中properties所在的packet。换句话说，两个所在位置不同的properties都被打包到了同一个路径下，即target中的classes，我们俗称这个路径为classpath。

五、HttpServletResponse（extends ServletResponse）

web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象，代表响应的一个HttpServletResponse。如果要获取客户端请求过来的参数，找HttpServletRequest；如果要给客户端响应一些信息，找HttpServletResponse

分类
负责向浏览器发送数据的方法：

ServletOutputStream getOutputStream() throws IOException;

PrintWriter getWriter() throws IOException;

负责向浏览器发送响应头的方法

    void setCharacterEncoding(String var1);

    void setContentLength(int var1);

    void setContentLengthLong(long var1);

    void setContentType(String var1);

    void setDateHeader(String var1, long var2);

    void addDateHeader(String var1, long var2);

    void setHeader(String var1, String var2);

    void addHeader(String var1, String var2);

    void setIntHeader(String var1, int var2);

    void addIntHeader(String var1, int var2);

响应状态码

    int SC_CONTINUE = 100;
    int SC_SWITCHING_PROTOCOLS = 101;
    int SC_OK = 200;
    int SC_CREATED = 201;
    int SC_ACCEPTED = 202;
    int SC_NON_AUTHORITATIVE_INFORMATION = 203;
    int SC_NO_CONTENT = 204;
    int SC_RESET_CONTENT = 205;
    int SC_PARTIAL_CONTENT = 206;
    int SC_MULTIPLE_CHOICES = 300;
    int SC_MOVED_PERMANENTLY = 301;
    int SC_MOVED_TEMPORARILY = 302;
    int SC_FOUND = 302;
    int SC_SEE_OTHER = 303;
    int SC_NOT_MODIFIED = 304;
    int SC_USE_PROXY = 305;
    int SC_TEMPORARY_REDIRECT = 307;
    int SC_BAD_REQUEST = 400;
    int SC_UNAUTHORIZED = 401;
    int SC_PAYMENT_REQUIRED = 402;
    int SC_FORBIDDEN = 403;
    int SC_NOT_FOUND = 404;
    int SC_METHOD_NOT_ALLOWED = 405;
    int SC_NOT_ACCEPTABLE = 406;
    int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
    int SC_REQUEST_TIMEOUT = 408;
    int SC_CONFLICT = 409;
    int SC_GONE = 410;
    int SC_LENGTH_REQUIRED = 411;
    int SC_PRECONDITION_FAILED = 412;
    int SC_REQUEST_ENTITY_TOO_LARGE = 413;
    int SC_REQUEST_URI_TOO_LONG = 414;
    int SC_UNSUPPORTED_MEDIA_TYPE = 415;
    int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
    int SC_EXPECTATION_FAILED = 417;
    int SC_INTERNAL_SERVER_ERROR = 500;
    int SC_NOT_IMPLEMENTED = 501;
    int SC_BAD_GATEWAY = 502;
    int SC_SERVICE_UNAVAILABLE = 503;
    int SC_GATEWAY_TIMEOUT = 504;
    int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

常见应用

向浏览器输出消息（前述）
下载文件

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        下载文件
//        1.获取文件路径(确保文件在resources中，可以直接复制粘贴进去)，这里的路径最好给绝对路径，指代明确
        String realPath ="F:\\IJ IDEA\\Projects\\javaweb04-servlet\\response\\target\\classes\\1.jpg";
        System.out.println("下载文件的路径："+realPath);
//        2.获取下载的文件名
        String filename = realPath.substring(realPath.lastIndexOf("\\") + 1);
//        3.设置消息头,让浏览器能支持该文件的下载（Content-Disposition）
        resp.setHeader("Content-Disposition","attachment;filename="+filename);
        //若文件名有中文，则需加上编码方式
        // resp.setHeader("Content-Disposition","attachment;filename="+URLEncoder.encode(filename,"UTF-8"));
//        4.获取文件的输入流
        FileInputStream in = new FileInputStream(realPath);
//        5.创建缓冲区
        int len=0;
        byte[] buffer = new byte[1024];
//        6.获取OutputStream对象
        ServletOutputStream out = resp.getOutputStream();
//        7.将FileOutputStream流写入到buffer缓冲区
        while ((len=in.read(buffer))>0){
            out.write(buffer,0,len);
        }
        in.close();
        out.close();
//        8.使用OutputStream将缓冲区中的数据输出到客户端
    }

验证码功能
· 前端实现
· 后端实现，需要用到java的图片类

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //让浏览器3秒自动刷新一次
        resp.setHeader("refresh","3");
        //1.在内存中创建一个图片
        BufferedImage image = new BufferedImage(80,20,BufferedImage.TYPE_INT_RGB);
        //2.画图
        Graphics2D g= (Graphics2D)image.getGraphics();//笔
        //设置图片的背景图片
        g.setColor(Color.white);
        g.fillRect(0,0,80,20);
        //给图片写数据
        g.setColor(Color.BLUE);
        g.setFont(new Font(null,Font.BOLD,20));
        g.drawString(makenumber(),0,20);
        //3.告诉浏览器，这个请求以图片的方式打开
        resp.setContentType("image/jpg");
        //4.网站存在缓存,不让浏览器缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");
        //5.把图片写给浏览器
        ImageIO.write(image,"jpg", resp.getOutputStream());

    }

实现重定向
客户端A请求一个web资源B后，B会通知A去访问另一个web资源C，该过程叫重定向。

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.sendRedirect("/resp/img");//重定向（/img为上一个的url-pattern）
        /*相当于：
         *resp.setHeader("Location","/resp/img");
         *resp.setStatus(302);
         */
    }

重定向和转发的区别

相同点：页面都会实现跳转
不同点：

请求转发的url不会发生变化，响应状态码为302
重定向的url会发生变化，响应状态码为307

六、HttpServletRequest

HttpServletRequest代表客户端的请求，用户通过http协议访问服务器，HTTP请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest方法获得客户端的所有信息。

获取前端传递的参数，并请求转发

以登录系统为例：
第一步，写登陆界面
删除重建index.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录title>
head>
<body>
<h1>登录h1>
<div style="text-align: center">
    <%--这里表单的意思是：以post方法提交表单，提交到servlet中的请求HttpServletRequest--%>
    <form action="${pageContext.request.contextPath}/login" method="post"><%--创建一个表单，并：获取服务器的请求路径为“/login”,该路径就是要调用的servlet的url；调用方法为“post”--%>
        用户名：<input type="text" name="username"><br><%--创建一个text文本框，变量名为username;<br>是换行操作--%>
        密码：<input type="password" name="password"><br><%--创建一个password密码框，变量名为password--%>
        爱好：
        <input type="checkbox" name="hobbies" value="女人">女人<%--创建checkbox多选框,以该选项框为例，变量名为hobby，其值为女人（前一个），在前端显示为“女人”（后一个）--%>
        <input type="checkbox" name="hobbies" value="足球">足球
        <input type="checkbox" name="hobbies" value="音乐">音乐
        <br>
        <input type="submit"><%--创建一个submit提交框--%>
    form>
div>
body>
html>

第二步，写登陆后的界面：
在webapp下新建success.jsp：

<body>
<h1>登录成功h1>
body>

第三步，获取前端传递的参数，并打印到后台，然后请求转发success.jsp：

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        String username = req.getParameter("username");//获取名为"username"的参数
        String password = req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobbies");
        System.out.println("==================");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbies));//打印数组
        System.out.println("==================");

        /*通过请求转发*/
        req.getRequestDispatcher("/success.jsp").forward(req,resp);//"/success.jsp"中的/就代表当前的web应用，因此也可以写为：
        //req.getRequestDispatcher(req.getContextPath()+"success.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }

七、会话

举例：用户打开一个浏览器，点击了很多链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话

两种有状态会话：
服务端给客户端一个信件，客户端下次访问服务端带上信件就可以访问了（cookie）
服务端给客户端登记，下次客户端访问时进行匹配（session）

保存会话的两种技术：
cookie

客户端技术（响应、请求）

session

服务器技术，可以保存用户的会话信息。我们可以把用户数据放进session中
常见场景：自动登录

1. Cookie

服务器从客户端的请求中获取Cookie、服务器新建cookie并把它响应给客户端：

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //过程描述：服务器告诉客户端访问的时间，把这个时间封装成一个信件，客户端再次访问时服务器就可以识别信件了

    //中文编码
    req.setCharacterEncoding("UTF-8");
    resp.setContentType("text/html;charset=UTF-8");

    PrintWriter out = resp.getWriter();

    //服务器从客户端的请求中获取Cookie
    Cookie[] cookies = req.getCookies();//一个客户端可以有多个Cookie，因此用数组
    if (cookies!=null){//判断cookie是否存在
        out.write("你上一次访问的时间是：");
        for (int i = 0; i < cookies.length; i++){
            Cookie cookie = cookies[i];
            if (cookie.getName().equals("lastLoginTime")){//cookie.getName()：获得cookie中的name（name-value）
                long lastLoginTime = Long.parseLong(cookie.getValue());//Long.parseLong：将String解析转化成long；cookie.getValue()：获得cookie中的value（name-value）
                Date date = new Date(lastLoginTime);//Date是用来表示时间的类
                out.write(date.toLocaleString());//本地时间格式化的方法
            }
        }
    }else {
        out.write("这是您第一次访问本站");
    }

    //服务器新建cookie并把它响应给客户端
    Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");//“System.currentTimeMillis()+""”可以将System.currentTimeMillis()返回值变成字符串，或者用String.valuesOf()
    cookie.setMaxAge(24*60*60);//设置cookie的有效期，此处为一天
    resp.addCookie(cookie); //服务器把cookie响应给客户端
}

Cookie基本原理：

客户端的cookie一般会保存在本地的用户目录下的appdata中
一个cookie只能保存一个信息
一个web站点可以给浏览器发送多个cookie，最多存放20个cookie
cookie大小有限制4kb
浏览器最多有300个cookie

删除cookie的两种途径：

不设置有效期，关闭浏览器自动失效
超过有效期

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //删除name为lastLoginTime的cookie
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");//创建一个cookie，名字必须要和要删除的名字一致
        cookie.setMaxAge(0);//立马过期

        resp.addCookie(cookie);
    }

String的中文编解码函数：

URLEncoder.encode("中文","utf-8")//返回一个编码后的String s
URLDecoder.decode(s,"utf-8")//返回中文String

2. Session

服务器会给每一个用户（浏览器）创建一个session对象
一个session独占一个浏览器，只要浏览器没有关闭，这个session就存在
用户登录后，整个网站都可以访问–>保存用户信息的功能

HttpSession方法一览：

idea技巧之 packege分包与取消分包的方式：

idea技巧之快速自动生成getter、setter等方法，或在xml中快速生成servlet等代码块：alt+insert

session和cookie的区别：

Cookie是把服务器用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
Session把服务器用户的数据写到用户独占Session中，服务器保存（保存重要的信息，减少服务器资源的浪费）
Session对象由服务器创建

应用场景：

保存一个登录用户的信息
购物车信息
在整个网站中经常会使用的数据，我们将它保存在session中

Session相关操作：

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //中文编码
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html");
        
        //得到session
        HttpSession session = req.getSession();

        //在session中存东西
        session.setAttribute("name", new Person("超", 1));

        //获取session的ID
        String sessionId = session.getId();

        //判断session是不是新创建的
        if (session.isNew()) {
            resp.getWriter().write("session 创建成功,ID=" + sessionId);
        }else{
            resp.getWriter().write("session已经在服务器中存在了,ID=" + sessionId);
        }

        /*//session创建的过程相当于:
        Cookie cookie = new Cookie("JSESSIONID",sessionId);
        resp.addCookie(cookie);*/
        
    }

会话过期：
方法一：

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        //仅删除session中的信息
        session.removeAttribute("name");
        //手动注销session
        session.invalidate();
    }

方法二：

    
    <session-config>
        
        <session-timeout>1session-timeout>
    session-config>

八、JSP

1. 基本原理

JSP，Java Sever Pages，Java服务器页面。和servlet一样，用于动态web技术

和HTML的区别：

HTML只给用户提供静态的数据
JSP页面可以嵌入JAVA代码，为用户提供动态数据

注意：

不管浏览器向服务器访问什么资源，都是在访问servlet，因此JSP最终会被转化成Java类，其本质上就是一个servlet
JSP编辑页面中的Java代码会被原封不动地输出到其Java类中，HTML代码（…）在Java类中会被转化为out.write(“…”)并最终输出到前端

原理：一个JSP底层包括判断请求、内置了一些对象（session、ServletContext、ServletConfig、HttpServletRequest、HttpServletResponse等）、输出页面前的代码

2. 基础语法

pom.xml：

		
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>servlet-apiartifactId>
            <version>2.5version>
        dependency>
        
        <dependency>
            <groupId>javax.servlet.jspgroupId>
            <artifactId>javax.servlet.jsp-apiartifactId>
            <version>2.3.3version>
        dependency>
        
        <dependency>
            <groupId>javax.servlet.jsp.jstlgroupId>
            <artifactId>jstlartifactId>
            <version>1.2version>
        dependency>
        
        <dependency>
            <groupId>taglibsgroupId>
            <artifactId>standardartifactId>
            <version>1.1.2version>
        dependency>

JSP作为Java技术的一种应用，它拥有一些自己的扩充语法。

JSP表达式：

  <body>
  <%--JSP表达式
  作用：用来将程序的输出，打印到客户端浏览器
  <%= 变量或者表达式%>
  --%>
  <%= new java.util.Date()%>
  body>

JSP脚本片段

  <hr><%--打印分割线--%>

  <%--JSP脚本片段--%>
  <%
    int sum = 0;
    for (int i = 1; i <= 100; i++){
      sum+=i;
    }
    out.println("<h1>Sum="+sum +"<h1>");/*out.println可以自动将括号内的语句作为HTML语言输出到前端HTML中*/
  %>

脚本片段的再实现

  <%--在代码中嵌入HTML元素--%>
  <%
    for (int i=0;i<5;i++){
  %>
  <h1>Hello, World! <%= i%> h1>
  <%
    }
  %>

整体打印效果：

JSP声明：<%! … %>，会被直接编译到JSP生成的java类中，作用域高于普通的<% … %>中的Java代码（生成到了类当中的jspService方法中）

  <%!
    static {
      System.out.println("Loading Servlet!");
    }
    
    private int globalVar = 0;

    public void ycr(){
      System.out.println("进入了方法ycr");
    }
  %>

<%–JSP的注释，不会在客户端的HTML源代码中显示–%>

3. JSP指令

设置文档编码方式、出现错误时跳转到某个页面。。。：

<%@ page ... %>

页面显示为一个图片：
先在web目录中新建一个resource目录（img），再在里面放入图片

<img src="/img/消息结构示例.jpg" alt="500error">

出现指定错误类型就转到某个jsp的页面：
web.xml中，

    <error-page>
        <error-code>404error-code>
        <location>/error/404.jsplocation>
    error-page>

	<%--@include将页面的代码拼接一起--%>
    <%@include file="/common/header.jsp"%>
    <h1>网页主体h1>
    <%@include file="/common/footer.jsp"%>

    <hr>

    <%--JSP标签
    jsp:include直接将页面拼接起来，本质还是不同页面
    --%>
    <jsp:include page="common/header.jsp"/>
    <h1>网页主体h1>
    <jsp:include page="common/footer.jsp"/>

4. 九大内置对象

pageContext ——存东西
request ——存东西
response
session ——存东西
application（即ServletContext） ——存东西
config（即ServletConfig）
out
page ——不用
exception

<%--内置对象--%>
<%
pageContext.setAttribute("name1","ycr1");//只在一个页面中有效
request.setAttribute("name2","ycr2");//只在一次请求中有效,请求转发会携带这个数据
session.setAttribute("name3","ycr3");//只在一次会话中有效,从打开浏览器到关闭
application.setAttribute("name4","ycr4");//只在服务器中有效,从打开服务器到关闭
%>

<%
    /*通过寻找的方式取出我们在pageContext中保存的值*/
    /*从作用域的底层到高层寻找,即pageContext-->request-->session-->application*/
    Object name1 = pageContext.findAttribute("name1");
    Object name2 = pageContext.findAttribute("name2");
    Object name3 = pageContext.findAttribute("name3");
    Object name4 = pageContext.findAttribute("name4");
    Object name5 = pageContext.findAttribute("name5");
%>

<%--使用EL表达式${}输出--%>
<h1>取出的值为：h1>
<h2>${name1}h2>
<h3>${name2}h3>
<h4>${name3}h4>
<h5>${name4}h5>
<h6>${name5}h6>
<%--<h6><%=name5%>h6>--%>

<%
/*请求转发*/
pageContext.forward("/index.jsp");
//request.getRequestDispatcher("/index.jsp").forward(request,response);
%>

request：客户端向服务器发送请求产生的数据，用户关闭网页后就看不到了，例如新闻
session：客户端向服务器发送请求产生的数据，用户关闭网页后服务器仍然保存，例如购物车
application：客户端向服务器发送请求产生的数据，一个用户关闭网页后，其他用户能看见，例如聊天数据

5. JSP标签、JSTL标签、EL表达式

EL表达式：获取数据、执行运算、获取web开发的常用对象

注意导入javax.servlet.jsp.jstl、taglibs的dependency，并找到他俩所在的文件夹，将这两个的jar包复制粘贴到tomcat的lib目录中

JSP标签：

<jsp:forward page="jsptag2.jsp">
    <jsp:param name="name" value="应"/>
    <jsp:param name="age" value="18"/>
jsp:forward>

JSTL标签：
JSTL标签库的使用就是为了弥补HTML标签的不足，它自定义许多标签，可以供我们使用，标签的功能和Java代码一样。包括核心标签、格式化标签、SQL标签、XML标签。
JSTL核心标签库的使用：

<%--要使用JSTL核心标签库，先引入--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

if实例：

<h4>if测试h4>

<hr>

<form action="coreif.jsp" method="get"><%--coreif.jsp就是当前jsp文件, 这句话作用是将username的值提交到这个请求中,并在下面JSTL标签语句块中做判断--%>
    <%--EL表达式获取表单中的数据：${param.参数名}--%>
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="登录">
form>

<%--判断如果提交的用户是管理员，则登陆成功--%>
<c:if test="${param.username='admin'}" var="isAdmin">
    <c:out value="welcome"/>
c:if>

<c:out value="${isAdmin}"/>

switch实例：

<%--定义一个叫score的变量，值为85--%>
<c:set var="score" value="85"/>

<c:choose>
    <c:when test="${score>=90}">
        你的成绩为优秀
    c:when>
    <c:when test="${score>=80}">
        你的成绩为一般
    c:when>
    <c:when test="${score>=70}">
        你的成绩为良好
    c:when>
    <c:when test="${score<=60}">
        你的成绩为差
    c:when>
c:choose>

for实例：

<%
    ArrayList<String> people = new ArrayList<>();
    people.add(0,"张三");
    people.add(1,"李四");
    people.add(2,"王二");
    people.add(3,"麻子");
    request.setAttribute("list", people);
%>

<%--var为每一次遍历出来的变量；items为要遍历的对象--%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"/><br>
c:forEach>

<hr>

<%--begin、end和step分别为遍历的开始位置、结束位置和步长--%>
<c:forEach begin="1" end="3" step="2" var="people" items="${list}">
    <c:out value="${people}"/><br>
c:forEach>

九、JavaBean

相当于pojo(Plain Ordinary Java Object)、entity（实体类）

实体类，有特定的写法：

必须有一个无参构造
属性必须私有化
必须有对应的get/set方法

一般用来和数据库的字段做映射 ORM（对象关系映射）

表–>类
字段–>属性
行记录–>对象

一个表

id	name	age	address
1	y1	10	西电北
2	y2	20	西电南

对应到Java对象:

import lombok.Data;
@Data
//实体类一般都是和数据库中的表结构一一对应的
public class people {
    private int id;
    private String name;
    private int age;
    private String address;  
}

<body>
<%
/*    people people = new people();
    people.setAddress("xi'an");
    people.setAge(18);
    people.setId(1);
    people.setName("ycr");*/
%>
<jsp:useBean id="people" class="com.y.pojo.people" scope="page" />

<jsp:setProperty name="people" property="address" value="xi'an"/>
<jsp:setProperty name="people" property="id" value="1"/>
<jsp:setProperty name="people" property="age" value="18"/>
<jsp:setProperty name="people" property="name" value="ycr"/>

姓名：<jsp:getProperty name="people" property="name"/>
id：<jsp:getProperty name="people" property="id"/>
年龄：<jsp:getProperty name="people" property="age"/>
地址<jsp:getProperty name="people" property="address"/>

body>

重要技巧之Lombok

通过Lombok插件我们只需要编写需要的属性类型、属性即可，构造器、toString方法可以通过对应的注解实现，不再需要我们构建：Lombok基本使用方法

@Getter/@Setter: 作用类上，生成所有成员变量的getter/setter方法；
	作用于成员变量上，生成该成员变量的getter/setter方法。
	
@ToString: 作用于类，覆盖默认的toString()方法

@EqualsAndHashCode: 作用于类，覆盖默认的equals和hashCode

@NoArgsConstructor：生成无参构造器；

@RequiredArgsConstructor：生成包含final和@NonNull注解的成员变量的构造器；

@AllArgsConstructor：生成全参构造器

@Data: 作用于类上，注解集合，使用它相当于使用下列注解：
	@ToString 
	@EqualsAndHashCode 
	@Getter 
	@Setter 
	@RequiredArgsConstructor

@Builder: 作用于类上，将类转变为建造者模式

@Log: 作用于类上，生成日志变量

十、MVC三层架构

MVC：model模型、view视图（JSP）、controller控制器（servlet）

架构思想：

从前，用户直接访问控制层，控制层再直接操作数据库。这样会带来程序臃肿、不便维护等弊端，然而可以通过一层一层增加架构来解决。例如：

通过JDBC提供的接口来操作数据库，而不必亲自操作数据库
让Servlet专注于处理请求以及控制视图跳转
让JSP专注于显示数据
…

综上，提出MVC架构：

model：

业务处理：业务逻辑（Service）
数据持久层：CRUD增删改查（Dao）

view：

展示数据
提供链接发起Servlet请求（a链接、form表单、img）

controller：

接收用户请求：req参数、session
交给业务层处理对应的代码
控制视图的跳转

十一、Filter（重点）

处理中文乱码
登录验证

idea技巧之快速添加web框架支持：

对于一个普通maven项目，

自动生成，

过滤器开发步骤：

导包

    <dependencies>
        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>servlet-apiartifactId>
            <version>2.5version>
        dependency>
        <dependency>
            <groupId>javax.servlet.jspgroupId>
            <artifactId>javax.servlet.jsp-apiartifactId>
            <version>2.3.3version>
        dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstlgroupId>
            <artifactId>jstlartifactId>
            <version>1.2version>
        dependency>
        <dependency>
            <groupId>taglibsgroupId>
            <artifactId>standardartifactId>
            <version>1.1.2version>
        dependency>
        
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.28version>
        dependency>
    dependencies>

编写并配置过滤器

package com.y.filter;

import javax.servlet.*;//注意要导servlet中的Filter
import java.io.IOException;

public class CharacterEncodingFilter implements Filter {
    //初始化:web服务器启动时初始化,随时等待过滤对象出现
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("字符编码过滤器初始化");
    }
    
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletResponse.setContentType("text/html;charset=UTF-8");
        System.out.println("字符编码过滤器执行前");
        filterChain.doFilter(servletRequest,servletResponse);//让程序继续运行,否则程序就被拦截停止了
        System.out.println("字符编码过滤器执行后");
    }

    //销毁:web服务器关闭的时候销毁过滤器
    public void destroy() {
        System.out.println("字符编码过滤器销毁");
    }
}

被过滤的servlet源码：

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().print("你好世界");
    }

web.xml：

    <filter>
        <filter-name>characterEncodingFilterfilter-name>
        <filter-class>com.y.filter.CharacterEncodingFilterfilter-class>
    filter>
    <filter-mapping>
        <filter-name>characterEncodingFilterfilter-name>
        
        <url-pattern>/servlet/*url-pattern>
    filter-mapping>
    <servlet>
        <servlet-name>servletShowservlet-name>
        <servlet-class>com.y.servlet.ServletShowservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>servletShowservlet-name>
        <url-pattern>/showurl-pattern>
    servlet-mapping>
    <servlet-mapping>
        <servlet-name>servletShowservlet-name>
        <url-pattern>/servleturl-pattern>
    servlet-mapping>

测试

启动服务器，

紧接着刷新上面的页面，查看控制台发现又执行了一次过滤器，

停止tomcat服务器，

十二、监听器

监听器Listener有很多种，下面只举例一种说明监听器的开发：

实现监听器接口，

//统计网上在线人数：统计session
public class OnlineCountListener implements HttpSessionListener {
    //创建session监听:
    //一旦创建session就会触发以下事件
    public void sessionCreated(HttpSessionEvent httpSessionEvent) {
        ServletContext servletContext = httpSessionEvent.getSession().getServletContext();
        System.out.println(httpSessionEvent.getSession().getId());
        Integer onlineCount = (Integer) servletContext.getAttribute("OnlineCount");//注意Integer和int不一样
        if (onlineCount == null)
            onlineCount = new Integer(1);
        else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count+1);
        }
        servletContext.setAttribute("OnlineCount", onlineCount);
    }

    //销毁session监听
    //一旦销毁session就会触发以下事件.销毁session的方法见Session部分
    public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
        ServletContext servletContext = httpSessionEvent.getSession().getServletContext();
        Integer onlineCount = (Integer) servletContext.getAttribute("OnlineCount");//注意Integer和int不一样
        if (onlineCount == null)
            onlineCount = new Integer(1);
        else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count-1);
        }
        servletContext.setAttribute("OnlineCount", onlineCount);
    }
}

index.jsp，（这里总结了在jsp中获取ServletContext参数值（Attribute）的几个方法）

<body>

  <h1>当前有${OnlineCount}在线...EL表达式h1>
  <h1>当前有<%=pageContext.getServletContext().getAttribute("OnlineCount")%>在线...JSP的pageContext对象h1>
  <h1>当前有<%=application.getAttribute("OnlineCount")%>在线...JSP的application对象h1>

  $END$
  body>

web.xml中配置，

    <listener>
        <listener-class>com.y.listener.OnlineCountListenerlistener-class>
    listener>

测试，

十三、过滤器、监听器常见应用

监听器在GUI图形用户界面的应用：见Java基础

登录系统以及用过滤器实现登陆权限拦截：

用户登陆页面、登陆成功页面、登陆失败页面

<body>

<h1>登录h1>

<form action="/servlet/login" method="post"><%--将用户输入的参数提交到url为/servlet/login的服务器的请求中--%>
    <input type="text" name="username">
    <input type="submit">
form>

<body>

<%--先判断session中是否有USER_NAME参数,如果有,就意味着登陆成功,可以返回访问该页面.该部分可以用过滤器来实现--%>
<%--
<%
    Object user_session = request.getSession().getAttribute(Constant.USER_SESSION);
    if (user_session == null){
        pageContext.forward("/sys/login.jsp");//请求转发到/sys/login.jsp页面
    }
%>
--%>

<h1>主页h1>

<p>
    <a href="/sys/login.jsp">注销a><%--按钮,名字显示为"注销",用户点击后跳转到/servlet/logoin--%>
p>

body>
html>

<body>

<h1>用户名错误h1>

<a href="/servlet/login">返回登陆界面a>

body>

如果登陆成功，就向session中放入参数，并重定向到登陆成功页面
，否则直接重定向到登陆失败页面

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取前端请求参数
        String username = req.getParameter(Constant.USER_SESSION);
        if (username.equals("admin")){//登陆成功
            req.getSession().setAttribute(Constant.USER_SESSION, req.getSession().getId());//将参数USER_SESSION的值设置为该session的ID
            resp.sendRedirect("/sys/success.jsp");//重定向
        }else{//登陆失败
            resp.sendRedirect("/sys/fail.jsp");//重定向
        }
    }

用户直接访问登陆成功页面时，需要判断是否登陆成功过，如果没有就拦截并跳转到登陆失败页。该部分用过滤器来实现最便捷

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        /*HttpServletRequest是ServletRequest的子类,因此可以强转*/
        HttpServletRequest httprequest = (HttpServletRequest) request;
        HttpServletResponse httpresponse = (HttpServletResponse) response;

        /*判断session中是否有USER_NAME参数,如果没有,就意味着登陆失败,跳转到登陆失败页面*/
        if (httprequest.getSession().getAttribute(Constant.USER_SESSION) == null){
            httpresponse.sendRedirect("/sys/fail.jsp");//请求转发到/sys/fail.jsp页面
        }

        chain.doFilter(request, response);//filter中必须包含的语句
    }

    <filter>
        <filter-name>SysFilterfilter-name>
        <filter-class>com.y.filter.SysFilterfilter-class>
    filter>
    <filter-mapping>
        <filter-name>SysFilterfilter-name>
        <url-pattern>/sys/success.jspurl-pattern>
    filter-mapping>

重要技巧之静态static变量的使用:

package com.y.util;

/*把登录拦截示例中session的参数名(String)设置为静态变量,并在其他程序中用"Constant.USER_SESSION"调用,这样做的好处是今后在修改这个变量名的时候直接在这个程序中修改就可以了,而不需要在其他程序中再逐个修改*/
public class Constant {
    public final static String USER_SESSION = "USER_SESSION";
}

十四、回顾JDBC

idea技巧之快速键入main()方法的声明

输入“psvm”，会自动跳出快捷键

idea技巧之快速键入“System.out.println()”

输入“sout”，会自动跳出快捷键

pom.xml导入版本与本地数据库相同的依赖
将IDEA与MySQL连接
（1和2见Java基础）
编写JDBC程序

public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息;解决中文乱码:...?useUnicode=true&characterEncoding=utf-8
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123321";

        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //3.向数据库发送SQL语句的对象
        Statement statement = connection.createStatement();
        //4.编写SQL,含义是查询所有行所有列
        String sql = "select * from users;";
        //5.执行SQL查询语句,返回一个ResultSet结果集
        ResultSet resultSet = statement.executeQuery(sql);

        while (resultSet.next()){
            System.out.println("id="+resultSet.getObject("id"));
            System.out.println("name="+resultSet.getObject("name"));
            System.out.println("password="+resultSet.getObject("password"));
            System.out.println("email="+resultSet.getObject("email"));
            System.out.println("birthday="+resultSet.getObject("birthday"));
        }

        //6.关闭连接释放资源,顺序是先开的后关
        resultSet.close();
        statement.close();
        connection.close();
    }

预编译的SQL：

public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息;解决中文乱码:...?useUnicode=true&characterEncoding=utf-8
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123321";

        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //3.编写SQL
        /*String sql = "select * from users;";*/
        String sql = "insert into users(id, name,password, email,birthday) values (?,?,?,?,?)";
        //4.预编译的对象
        PreparedStatement preparedStatement=connection.prepareStatement(sql);
        preparedStatement.setInt(1,4);//给第一个占位符?的值赋为1
        preparedStatement.setString(2,"ycr");
        preparedStatement.setString(3,"1");
        preparedStatement.setString(4,"1");
        preparedStatement.setString(5,"1999-6-17");

        //5.执行SQL增删改语句;statement.executeUpdate()返回受影响的行数,例如这里的i=1
        int i = preparedStatement.executeUpdate();

        //6.关闭连接释放资源,顺序是先开的后关
        preparedStatement.close();
        connection.close();
    }

JDBC事务：
ACID原则：保证数据的安全
开启事务、事务提交、事务回滚、关闭事务

重要技巧之junit单元测试可以对某个方法单独运行而无需main()方法：

pom.xml（注意要把语句删掉）：


        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>

测试方法必须是无参的

转账实例机制：name为张三的money减少100，李四的增加100，中间设置一个错误异常（int i=1/0;），如果检测到异常就执行回滚操作。那么张三付款后会遇到异常导致李四收不到款，并且系统会检测到异常而撤销张三的付款操作。

import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class TestJdbc3 {
    @Test
    public void test(){
        //配置信息;解决中文乱码:...?useUnicode=true&characterEncoding=utf-8
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123321";

        Connection connection = null;
        try {
            //1.加载驱动
            Class.forName("com.mysql.jdbc.Driver");

            //2.连接数据库
            connection = DriverManager.getConnection(url, username, password);

            //3.通知数据库开启事务,默认是关闭(true),相当于关闭自动进行commit命令,那么执行结果缓会存在程序中而不会提交到数据库中
            connection.setAutoCommit(false);

            String sql = "update users set money = money-100 where name = '张三';";
            connection.prepareStatement(sql).executeUpdate();

            //制造错误
            int i=1/0;

            String sql2 = "update users set money = money+100 where name = '李四';";
            connection.prepareStatement(sql2).executeUpdate();

            connection.commit();//上面的SQL都执行成功就提交事务
        } catch (Exception e) {
            //如果出现异常就通知数据库回滚,回滚就是撤销已进行未提交的操作
            try {
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

运行前后张三和李四的money值不变；注释“int i=1/0;”后张三少100，李四多100。

十五、Ajax

Asynchronous JavaScript and XML，是一种在无需重新加载整个页面的情况下，能够更新部分网页的技术。例如：在搜索框输入关键字时，JavaScript会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表。

直接使用jQuery提供的Ajax，而不是js的。jQuery提供了多个与Ajax有关的方法。Ajax的本质是XMLHttpRequest对象（XHR），XHR为向服务器发送请求和解析服务器响应提供了接口，能够以异步的方式从服务器获取新数据。

使用（.js文件）：

编写Ajax需要导入jQuery包，或自己原生态实现；
Ajax的请求包括：1.type：“GET”或“POST”;2.url：Controller请求，它返回消息或者字符串或者json格式的数据，例如请求将被提交到的servlet的url；3.data：请求中传递的参数，键值对形式；4.dataType：通常为"json"，主流开发都是用JSON实现前后端；5.success：回调函数；
Ajax会绑定事件，例如点击click、失去焦点onblur、键盘弹起keyup。

十六、项目搭建实战（超市订单管理系统SMBMS）

1、准备工作

搭建maven项目
配置tomcat
测试运行
导入项目中会用到的jar包

    <dependencies>
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>servlet-apiartifactId>
            <version>2.5version>
        dependency>
        <dependency>
            <groupId>javax.servlet.jspgroupId>
            <artifactId>javax.servlet.jsp-apiartifactId>
            <version>2.3.3version>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.17version>
        dependency>
    	dependency>
    	<dependency>
		    <groupId>javax.servlet.jsp.jstlgroupId>
		    <artifactId>jstlartifactId>
		    <version>1.2version>
    	dependency>
    	<dependency>
      		<groupId>taglibsgroupId>
      		<artifactId>standardartifactId>
      		<version>1.1.2version>
    	dependency>
    dependencies>

创建项目包结构

编写实体类

ORM过程：定义与数据库columns对应的private型参量及其get、set等方法，详见pojo包的文件

编写基础公共类

数据库配置文件(resource.database.properties)

driver=com.mysql.jdbc.Driver #必须
url=jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=utf-8 #数据库的url地址+编码方式
user=root #数据库用户名
password=123321 #数据库密码

编写数据库的公共类
DAO：数据访问对象，是一个面向对象的数据库接口

package com.y.dao;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 操作数据库的基类--静态类
 * @author Administrator
 *
 */
public class BaseDao {
	
	static{//静态代码块,在类加载的时候执行
		init();
	}
	
	private static String driver;
	private static String url;
	private static String user;
	private static String password;
	
	//初始化连接参数,从配置文件.properties里获得
	public static void init(){
		Properties params=new Properties();
		String configFile = "database.properties";
		InputStream is=BaseDao.class.getClassLoader().getResourceAsStream(configFile);//通过类加载器ClassLoader获取对应文件的资源,或者可以用ServletContext获取
		try {
			params.load(is);
		} catch (IOException e) {
			e.printStackTrace();
		}
		driver=params.getProperty("driver");
		url=params.getProperty("url");
		user=params.getProperty("user");
		password=params.getProperty("password");

	}   
	
	
	/**
	 * 获取数据库连接
	 * @return
	 */
	public static Connection getConnection(){
		Connection connection = null;
		try {
			Class.forName(driver);
			connection = DriverManager.getConnection(url, user, password);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return connection;
	}
	/**
	 * 查询操作
	 * @param connection
	 * @param pstm
	 * @param rs
	 * @param sql
	 * @param params
	 * @return
	 */
	public static ResultSet execute(Connection connection,PreparedStatement pstm,ResultSet rs,
			String sql,Object[] params) throws Exception{//将PreparedStatement和 ResultSet也提到参数里是为了方便统一关闭close
		pstm = connection.prepareStatement(sql);
		for(int i = 0; i < params.length; i++){
			pstm.setObject(i+1, params[i]);//使pstm有params.length个占位符;pstm的占位符是从1开始的,而不是0
		}
		rs = pstm.executeQuery();//前面的SQL是预编译的,因此这里不需要再加sql
		return rs;
	}
	/**
	 * 更新操作
	 * @param connection
	 * @param pstm
	 * @param sql
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public static int execute(Connection connection,PreparedStatement pstm,
			String sql,Object[] params) throws Exception{
		int updateRows = 0;
		pstm = connection.prepareStatement(sql);
		for(int i = 0; i < params.length; i++){
			pstm.setObject(i+1, params[i]);
		}
		updateRows = pstm.executeUpdate();
		return updateRows;
	}
	
	/**
	 * 释放资源
	 * @param connection
	 * @param pstm
	 * @param rs
	 * @return
	 */
	public static boolean closeResource(Connection connection,PreparedStatement pstm,ResultSet rs){
		boolean flag = true;
		if(rs != null){
			try {
				rs.close();
				rs = null;//GC回收
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				flag = false;
			}
		}
		if(pstm != null){
			try {
				pstm.close();
				pstm = null;//GC回收
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				flag = false;
			}
		}
		if(connection != null){
			try {
				connection.close();
				connection = null;//GC回收
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				flag = false;
			}
		}
		
		return flag;
	}

}

编写字符编码过滤器
其中设置编码语句为

		request.setCharacterEncoding("UTF-8");
		response.setCharacterEncoding("UTF-8");

导入静态资源
导入到webapp下

功能实现阶段——先画出功能的MVC三层架构，再从底向上逐层实现功能：

2、登录功能实现

View层

编写前端页面
设置首页
web.xml:

    
    <welcome-file-list>
        <welcome-file>login.jspwelcome-file>
    welcome-file-list>

Modle层

DAO层

接口:通过userCode获取User的方法(interface com.y.dao.user.UserDao )

	public User getLoginUser(Connection connection, String userCode)throws Exception;

实现类:实现上述方法(class com.y.dao.user.UserDaoImpl)

	public User getLoginUser(Connection connection, String userCode)
			throws Exception {
		PreparedStatement pstm = null;
		ResultSet rs = null;
		User user = null;
		if(null != connection){
			String sql = "select * from smbms_user where userCode=?";//"?"为一个占位符
			Object[] params = {userCode};
			rs = BaseDao.execute(connection, pstm, rs, sql, params);
			if(rs.next()){
				user = new User();
				user.setId(rs.getInt("id"));
				user.setUserCode(rs.getString("userCode"));
				user.setUserName(rs.getString("userName"));
				user.setUserPassword(rs.getString("userPassword"));
				user.setGender(rs.getInt("gender"));
				user.setBirthday(rs.getDate("birthday"));
				user.setPhone(rs.getString("phone"));
				user.setAddress(rs.getString("address"));
				user.setUserRole(rs.getInt("userRole"));
				user.setCreatedBy(rs.getInt("createdBy"));
				user.setCreationDate(rs.getTimestamp("creationDate"));
				user.setModifyBy(rs.getInt("modifyBy"));
				user.setModifyDate(rs.getTimestamp("modifyDate"));
			}
			BaseDao.closeResource(null, pstm, rs);
		}
		return user;
	}

idea技巧之快速键入某个参数的非空判断语句和@NotNull插件

得到,

@NotNull插件:@NotNull后的参数不能为空,否则不合法
参数定义处:

import org.jetbrains.annotations.NotNull;

@NotNull Connection connection

service层

接口:该层通过调用dao层，判断用户名和密码是否正确并返回适当的用户数据（User类对象）（Interface com.y.service.user.UserService）

	public User login(String userCode, String userPassword);

实现类(class com.y.service.user.UserServiceImpl)

重要技巧之方便地对底层属性和方法进行调用

在service层的实现类中，声明一个底层的接口或类的对象，并在构造方法中创建该对象（new），例如在UserServiceImpl中：

	/*引入UserDao,方便下面的所有方法调用DAO的属性和方法*/
	private UserDao userDao;
	public UserServiceImpl(){
		userDao = new UserDaoImpl();
	}

	public User login(String userCode, String userPassword) {
		Connection connection = null;
		User user = null;
		try {
			connection = BaseDao.getConnection();
			user = userDao.getLoginUser(connection, userCode);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseDao.closeResource(connection, null, null);
		}
		//匹配密码
		if(null != user){
			if(!user.getUserPassword().equals(userPassword))
				user = null;
		}
		return user;
	}

Controller/Servlet层

编写servlet(class com.y.servlet.user.LoginServle)

public class LoginServlet extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		System.out.println("login ============ " );
		//获取用户名和密码
		String userCode = request.getParameter("userCode");
		String userPassword = request.getParameter("userPassword");
		//调用service方法，进行用户匹配
		UserService userService = new UserServiceImpl();
		User user = userService.login(userCode,userPassword);
		if(null != user){//登录成功
			//放入session
			request.getSession().setAttribute(Constants.USER_SESSION, user);
			//页面跳转（frame.jsp）
			response.sendRedirect("jsp/frame.jsp");
		}else{
			//页面跳转（login.jsp）带出提示信息--转发
			request.setAttribute("error", "用户名或密码不正确");
			request.getRequestDispatcher("login.jsp").forward(request, response);
		}
	}

根据login.jsp中相应表单的服务器路径来注册servlet

3. 登录功能优化

登录注销功能:删除session,返回登录页面(class com.y.servlet.user.LogoutServlet)

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		//清除session
		request.getSession().removeAttribute(Constants.USER_SESSION);
		response.sendRedirect(request.getContextPath()+"/login.jsp");
	}

登录拦截功能(class com.y.filter.SysFilter)

public class SysFilter implements Filter {
	public void init(FilterConfig filterConfig) throws ServletException {}
	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {

		System.out.println("SysFilter doFilter()===========");
		HttpServletRequest rq = (HttpServletRequest)request;
		HttpServletResponse rp = (HttpServletResponse)response;
		User userSession = (User)rq.getSession().getAttribute("userSession");
		if(null == userSession){
			rp.sendRedirect("/SMBMS/error.jsp");
		}else{
			chain.doFilter(request, response);//该方法是为了寻找下一个过滤器,因此被拦截的用户就不用继续寻找过滤器了
		}
	}
	public void destroy() {}
}

    <filter>
        <filter-name>sysFilterfilter-name>
        <filter-class>com.y.filter.SysFilterfilter-class>
    filter>
    <filter-mapping>
        <filter-name>sysFilterfilter-name>
        <url-pattern>/jsp/*url-pattern>
    filter-mapping>

4. 密码修改功能实现

View层

编写前端页面

Model层

DAO层

interface UserDao：

	/*修改当前用户密码*/
	public int updatePwd(Connection connection, int id, String pwd)throws Exception;

class UserDaoImpl：

	public int updatePwd(Connection connection, int id, String pwd)
			throws Exception {
		// TODO Auto-generated method stub
		int flag = 0;
		PreparedStatement pstm = null;
		if(connection != null){
			String sql = "update smbms_user set userPassword= ? where id = ?";
			Object[] params = {pwd,id};
			flag = BaseDao.execute(connection, pstm, sql, params);
			BaseDao.closeResource(null, pstm, null);
		}
		return flag;
	}

Service层

interface UserService

	/*根据userId修改密码*/
	public boolean updatePwd(int id, String pwd);

class UserServiceImpl

	public boolean updatePwd(int id, String pwd) {
		boolean flag = false;
		Connection connection = null;
		try{
			connection = BaseDao.getConnection();
			if(userDao.updatePwd(connection,id,pwd) > 0)
				flag = true;
		}catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseDao.closeResource(connection, null, null);
		}
		return flag;
	}

Controller/Servlet层

class com.y.servlet.user.UserServlet

重要技巧之Servlet复用

public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		//servlet的复用
		
		String method = request.getParameter("method");//从前端取出不同页面下的"method"参数
		
		System.out.println("method----> " + method);
		
		if(method != null && method.equals("add")){
			//增加操作
			this.add(request, response);
		}else if(method != null && method.equals("query")){
			this.query(request, response);
		}else if(method != null && method.equals("getrolelist")){
			this.getRoleList(request, response);
		}else if(method != null && method.equals("ucexist")){
			this.userCodeExist(request, response);
		}else if(method != null && method.equals("deluser")){
			this.delUser(request, response);
		}else if(method != null && method.equals("view")){
			this.getUserById(request, response,"userview.jsp");
		}else if(method != null && method.equals("modify")){
			this.getUserById(request, response,"usermodify.jsp");
		}else if(method != null && method.equals("modifyexe")){
			this.modify(request, response);
		}else if(method != null && method.equals("pwdmodify")){
			this.getPwdByUserId(request, response);
		}else if(method != null && method.equals("savepwd")){
			this.updatePwd(request, response);
		}
		
	}

//修改密码
private void updatePwd(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		
		Object o = request.getSession().getAttribute(Constants.USER_SESSION);
		String newpassword = request.getParameter("newpassword");
		boolean flag = false;
		if(o != null && !StringUtils.isNullOrEmpty(newpassword)){//StringUtils.isNullOrEmpty(String))判断String是否为空
			UserService userService = new UserServiceImpl();
			flag = userService.updatePwd(((User)o).getId(),newpassword);
			if(flag){
				request.setAttribute(Constants.SYS_MESSAGE, "修改密码成功,请退出并使用新密码重新登录！");
				request.getSession().removeAttribute(Constants.USER_SESSION);//session注销
			}else{
				request.setAttribute(Constants.SYS_MESSAGE, "修改密码失败！");
			}
		}else{
			request.setAttribute(Constants.SYS_MESSAGE, "修改密码失败！");
		}
		request.getRequestDispatcher("pwdmodify.jsp").forward(request, response);
	}

5. 密码修改功能优化（Ajax）

在maven仓库中搜索fastjson，导入依赖
前端：Ajax
后端：根据Ajax的data的JSON参数键值对来实现功能

	//修改密码中的验证旧密码是否正确功能
	private void getPwdByUserId(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		Object o = request.getSession().getAttribute(Constants.USER_SESSION);
		String oldpassword = request.getParameter("oldpassword");//
		Map<String, String> resultMap = new HashMap<String, String>();
		
		if(null == o ){//session过期
			resultMap.put("result", "sessionerror");
		}else if(StringUtils.isNullOrEmpty(oldpassword)){//旧密码输入为空
			resultMap.put("result", "error");
		}else{
			String sessionPwd = ((User)o).getUserPassword();//将o强转为User类型再调用getUserPassword()方法
			if(oldpassword.equals(sessionPwd)){
				resultMap.put("result", "true");
			}else{//旧密码输入不正确
				resultMap.put("result", "false");
			}
		}
		response.setContentType("application/json");//设置响应的文本类型为"application/json"
		PrintWriter outPrintWriter = response.getWriter();
		outPrintWriter.write(JSONArray.toJSONString(resultMap));//JSONArray是阿里巴巴的JSON工具类,toJSONString(resultMap)将Map转化为JSON格式的String字符串
		outPrintWriter.flush();
		outPrintWriter.close();
	}

6. 用户管理功能实现

View层

用户列表页面：userlist.jsp

util

分页工具类

package com.y.util;
public class PageSupport {
	//当前页码-来自于用户输入
	private int currentPageNo = 1;
	
	//总数量（表）
	private int totalCount = 0;
	
	//页面容量
	private int pageSize = 0;
	
	//总页数-totalCount/pageSize（+1）
	private int totalPageCount = 1;

	public int getCurrentPageNo() {
		return currentPageNo;
	}

	public void setCurrentPageNo(int currentPageNo) {
		if(currentPageNo > 0){
			this.currentPageNo = currentPageNo;
		}
	}

	public int getTotalCount() {
		return totalCount;
	}

	public void setTotalCount(int totalCount) {
		if(totalCount > 0){
			this.totalCount = totalCount;
			//设置总页数
			this.setTotalPageCountByRs();
		}
	}
	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		if(pageSize > 0){
			this.pageSize = pageSize;
		}
	}

	public int getTotalPageCount() {
		return totalPageCount;
	}

	public void setTotalPageCount(int totalPageCount) {
		this.totalPageCount = totalPageCount;
	}
	
	public void setTotalPageCountByRs(){
		if(this.totalCount % this.pageSize == 0){
			this.totalPageCount = this.totalCount / this.pageSize;
		}else if(this.totalCount % this.pageSize > 0){
			this.totalPageCount = this.totalCount / this.pageSize + 1;
		}else{
			this.totalPageCount = 0;
		}
	}
}

Modle层

DAO层

UserDao和RoleDao

	/*通过条件查询-用户表记录数*/
	public int getUserCount(Connection connection, String userName, int userRole)throws Exception;
	/*通过条件查询-userList*/
	public List<User> getUserList(Connection connection, String userName, int userRole, int currentPageNo, int pageSize)throws Exception;

	//获取角色列表
	public List<Role> getRoleList(Connection connection)throws Exception;

UserDaoImpl（难点）和RoleDaoImpl

	public int getUserCount(Connection connection, String userName, int userRole)
			throws Exception {
		PreparedStatement pstm = null;
		ResultSet rs = null;
		int count = 0;
		if(connection != null){
			
			//根据不同的参数情况拼接出不同的sql命令
			StringBuffer sql = new StringBuffer();//StringBuffer的拼接方法append效率更高
			/*下面这句sql用到了多表拼接:将smbms_user和smbms_role两个表拼接(from u, r)后, 计算前者userRole的值等于smbms_role中id的值的条目数量(select count(1)),
			最终返回一个表给ResultSet,该表以"count"为列名(as count),以计数结果为条目*/
			sql.append("select count(1) as count from smbms_user u,smbms_role r where u.userRole = r.id");//count(1)比count(*)高效
			List<Object> list = new ArrayList<Object>();
			if(!StringUtils.isNullOrEmpty(userName)){
				//u.userName like "%"+userName+"%":userName这一列中包含username的条目.userName+"%"是以username开头的;"%"+userName是以username结尾的
				sql.append(" and u.userName like ?");//sql的两句话拼接时注意中间要有一个空格
				list.add("%"+userName+"%");
			}
			if(userRole > 0){
				sql.append(" and u.userRole = ?");
				list.add(userRole);
			}
			Object[] params = list.toArray();//List转数组的方法
			System.out.println("sql ----> " + sql.toString());

			rs = BaseDao.execute(connection, pstm, rs, sql.toString(), params);
			if(rs.next()){//rs的指针指向结果集的第一行
				count = rs.getInt("count");
			}
			BaseDao.closeResource(null, pstm, rs);
		}
		return count;
	}

	public List<User> getUserList(Connection connection, String userName,int userRole,int currentPageNo, int pageSize)
			throws Exception {
		PreparedStatement pstm = null;
		ResultSet rs = null;
		List<User> userList = new ArrayList<User>();
		if(connection != null){
			StringBuffer sql = new StringBuffer();
			sql.append("select u.*,r.roleName as userRoleName from smbms_user u,smbms_role r where u.userRole = r.id");
			List<Object> list = new ArrayList<Object>();
			if(!StringUtils.isNullOrEmpty(userName)){
				sql.append(" and u.userName like ?");
				list.add("%"+userName+"%");
			}
			if(userRole > 0){
				sql.append(" and u.userRole = ?");
				list.add(userRole);
			}

			sql.append(" order by creationDate DESC limit ?,?");//"limit currentPageNo, pageSize"只返回从currentPageNo(从0开始)开始的pageSize个条目
			currentPageNo = (currentPageNo-1)*pageSize;
			list.add(currentPageNo);
			list.add(pageSize);
			
			Object[] params = list.toArray();
			System.out.println("sql ----> " + sql.toString());
			rs = BaseDao.execute(connection, pstm, rs, sql.toString(), params);
			while(rs.next()){
				User _user = new User();
				_user.setId(rs.getInt("id"));
				_user.setUserCode(rs.getString("userCode"));
				_user.setUserName(rs.getString("userName"));
				_user.setGender(rs.getInt("gender"));
				_user.setBirthday(rs.getDate("birthday"));
				_user.setPhone(rs.getString("phone"));
				_user.setUserRole(rs.getInt("userRole"));
				_user.setUserRoleName(rs.getString("userRoleName"));
				userList.add(_user);
			}
			BaseDao.closeResource(null, pstm, rs);
		}
		return userList;
	}

public List<Role> getRoleList(Connection connection) throws Exception {
		PreparedStatement pstm = null;
		ResultSet rs = null;
		List<Role> roleList = new ArrayList<Role>();
		if(connection != null){
			String sql = "select * from smbms_role";
			Object[] params = {};
			rs = BaseDao.execute(connection, pstm, rs, sql, params);
			while(rs.next()){
				Role _role = new Role();
				_role.setId(rs.getInt("id"));
				_role.setRoleCode(rs.getString("roleCode"));
				_role.setRoleName(rs.getString("roleName"));
				roleList.add(_role);
			}
			BaseDao.closeResource(null, pstm, rs);
		}
		return roleList;
	}

Service层

UserService和RoleService

	/*根据条件查询用户表记录数 */
	public int getUserCount(String queryUserName, int queryUserRole);
	/*根据条件查询用户列表*/
	public List<User> getUserList(String queryUserName, int queryUserRole, int currentPageNo, int pageSize);

	public List<Role> getRoleList();

UserServiceImpl和RoleServiceImpl

	public int getUserCount(String queryUserName, int queryUserRole) {
		// TODO Auto-generated method stub
		Connection connection = null;
		int count = 0;
		System.out.println("queryUserName ---- > " + queryUserName);
		System.out.println("queryUserRole ---- > " + queryUserRole);
		try {
			connection = BaseDao.getConnection();
			count = userDao.getUserCount(connection, queryUserName,queryUserRole);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseDao.closeResource(connection, null, null);
		}
		return count;
	}
	
	public List<User> getUserList(String queryUserName,int queryUserRole,int currentPageNo, int pageSize) {
		Connection connection = null;
		List<User> userList = null;
		System.out.println("queryUserName ---- > " + queryUserName);
		System.out.println("queryUserRole ---- > " + queryUserRole);
		System.out.println("currentPageNo ---- > " + currentPageNo);
		System.out.println("pageSize ---- > " + pageSize);
		try {
			connection = BaseDao.getConnection();
			userList = userDao.getUserList(connection, queryUserName,queryUserRole,currentPageNo,pageSize);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			BaseDao.closeResource(connection, null, null);
		}
		return userList;
	}

	/*引入RoleDao*/
	private RoleDao roleDao;
	public RoleServiceImpl(){
		roleDao = new RoleDaoImpl();
	}

	public List<Role> getRoleList() {
		Connection connection = null;
		List<Role> roleList = null;
		try {
			connection = BaseDao.getConnection();
			roleList = roleDao.getRoleList(connection);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseDao.closeResource(connection, null, null);
		}
		return roleList;
	}

Controller/Servlet层

UserServlet（重难点）

//查询用户列表
	private void query(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		//获取前端数据
		String queryUserName = request.getParameter("queryname");
		String temp = request.getParameter("queryUserRole");
		String pageIndex = request.getParameter("pageIndex");
		int queryUserRole = 0;

		//调用UserService获取并返回用户列表
		UserService userService = new UserServiceImpl();
		List<User> userList = null;
    	int pageSize = Constants.pageSize;//设置页面容量
    	int currentPageNo = 1;//第一次查询的结果都是第一页,因此当前页码currentPageNo初始值为1
		/*//**//**//**//**//**//**//**//**
		 * http://localhost:8090/SMBMS/userlist.do
		 * ----queryUserName --NULL
		 * http://localhost:8090/SMBMS/userlist.do?queryname=
		 * --queryUserName ---""
		 *//**//**//**//**//**//**//**//*/
		*/
		System.out.println("queryUserName servlet--------"+queryUserName);  
		System.out.println("queryUserRole servlet--------"+queryUserRole);  
		System.out.println("query pageIndex--------- > " + pageIndex);
		if(queryUserName == null){
			queryUserName = "";
		}
		if(temp != null && !temp.equals("")){
			queryUserRole = Integer.parseInt(temp);//int parseInt(String s)是将s转化为整型,例如"2"-->2,"a"-->抛出异常
		}
    	if(pageIndex != null){
    		try{
    			currentPageNo = Integer.valueOf(pageIndex);
    		}catch(NumberFormatException e){
    			response.sendRedirect("error.jsp");
    		}
    	}
    	//1.分页
    	int totalCount	= userService.getUserCount(queryUserName,queryUserRole);//获取满足条件的用户数量
    	PageSupport pages=new PageSupport();
    	pages.setCurrentPageNo(currentPageNo);
    	pages.setPageSize(pageSize);
    	pages.setTotalCount(totalCount);
    	int totalPageCount = pages.getTotalPageCount();
    	//控制当前页currentPageNo的范围为1到totalPageCount
    	if(currentPageNo < 1){
    		currentPageNo = 1;
    	}else if(currentPageNo > totalPageCount){
    		currentPageNo = totalPageCount;
    	}
		//2.获取当前页的查询用户User和角色Role;3.获取完所有前端需要的信息后,向前端返回
		userList = userService.getUserList(queryUserName,queryUserRole,currentPageNo, pageSize);
		request.setAttribute("userList", userList);
		List<Role> roleList = null;
		RoleService roleService = new RoleServiceImpl();
		roleList = roleService.getRoleList();
		request.setAttribute("roleList", roleList);
		request.setAttribute("queryUserName", queryUserName);
		request.setAttribute("queryUserRole", queryUserRole);
		request.setAttribute("totalPageCount", totalPageCount);
		request.setAttribute("totalCount", totalCount);
		request.setAttribute("currentPageNo", currentPageNo);
		
		//请求转发到指定的前端页面
		request.getRequestDispatcher("userlist.jsp").forward(request, response);
	}

十七、文件上传

文件下载见本文二、HttpServletResponse

导入jar包：commons-io、commons-fileupload
使用类介绍

文件上传的注意事项：

为保证服务器安全，上传的文件应放在外界无法直接访问的目录下，比如WEB-INF
为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名，比如用时间戳命名、md5加密
要限制上传文件的最大值
可以限制上传文件的类型，在收到上传文件名时，判断后缀名是否合法

(1)前端HTML

防止中文乱码:

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>

在body标签内:

<%--通过表单上传文件
get方法上传文件大小有限制
post方法上传文件大小没有限制
--%>
<form action="${pageContext.request.contextPath}/upload.do" method="post" enctype="multipart/form-data">
    <p>用户名：<input type="text" name="username" placeholder="请填写用户名">p><%--p标签是段落标签,作用是分段--%>
    <p>上传文件：<input type="file" name="filename">p>
    <p><input type="submit" value="提交"><input type="reset" value="重置">p>
form>

(2)后端Servlet

ServletFileUpload负责处理上传的文件数据，并将表单中的每个输入项封装成一个FileItem对象，在使用ServletFileUpload对象解析请求时需要DiskFileItemFactory对象。所以，我们需要在进行解析工作前构造好DiskFileItemFactory对象，通过ServletFileItem对象的构造方法或setFileItemFactory()设置ServletFileUpload对象的fileItemFactory属性。

public class FileServlet extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws javax.servlet.ServletException, IOException {
            //判断上传的表单是普通表单还是带文件的表单，是返回true,否返回false；
            if (!ServletFileUpload.isMultipartContent(request)){
                return;//如果这是一个普通表单就直接终止方法运行
            }//如果通过了这个if，说明我们的表单是带文件上传的

            //创建上传文件的保存目录，为了安全建议在WEB-INF目录下，用户无法访问
            String uploadpath = this.getServletContext().getRealPath("/WEB-INF/Upload");//获取上传文件的保存路径
            File uploadfile = new File(uploadpath);
            if (!uploadfile.exists()){
                uploadfile.mkdir();//如果目录不存在就创建这样一个目录
            }

            //临时文件
            //临时路径，如果上传的文件超过预期的大小，我们将它存放到一个临时目录中，过几天自动删除，或者提醒用户转存为永久
            String tmppath = this.getServletContext().getRealPath("/WEB-INF/tmp");
            File file = new File(tmppath);
            if (!file.exists()){
                file.mkdir();//如果目录不存在就创建这样临时目录
            }
            //处理上传的文件一般需要通过流来获取，我们可以通过request.getInputstream(),原生态文件上传流获取，十分麻烦
            //但是我们都建议使用Apache的文件上传组件来实现，common-fileupload,它需要依赖于common-io组件；

            try {
                //1、创建DiskFileItemFactory对象，处理文件上传路径或限制文件大小
                DiskFileItemFactory factory = gteDiskFileItemFactory(file);
                //2、获取ServletFileUpload
                ServletFileUpload upload = getServletFileUpload(factory);
                //3、处理上传文件
                String msg = uploadParseRequest(upload,request,uploadpath);
                //Servlet请求转发消息
                request.setAttribute("msg",msg);
                request.getRequestDispatcher("/info.jsp").forward(request,response);
            }catch (FileUploadException e){
                e.printStackTrace();
            }
        }
        public static DiskFileItemFactory gteDiskFileItemFactory(File file){
            //1、创建DiskFileItemFactory对象，处理文件上传路径或限制文件大小
            DiskFileItemFactory factory = new DiskFileItemFactory();
            //通过这个工厂设置一个缓冲区，当上传的文件大小大于缓冲区的时候，将它放到临时文件中；
            factory.setSizeThreshold(1024 * 1024);//缓冲区大小为1M
            factory.setRepository(file);
            return factory;
        }
        public static ServletFileUpload getServletFileUpload(DiskFileItemFactory factory){
            //2、获取ServletFileUpload
            ServletFileUpload upload = new ServletFileUpload(factory);
            //监听文件上传进度
            upload.setProgressListener(new ProgressListener() {
                public void update(long pBytesRead, long lpContentLenght, int i) {
                    //pBytesRead:已读取到的文件大小
                    //pContentLenght：文件大小
                    System.out.println("总大小："+lpContentLenght+"已上传："+pBytesRead);
                }
            });
            //处理乱码问题
            upload.setHeaderEncoding("UTF-8");
            //设置单个文件的最大值
            upload.setFileSizeMax(1024 * 1024 * 10);
            //设置总共能够上传文件的大小
            //1024 = 1kb * 1024 = 1M * 10 = 10M
            upload.setSizeMax(1024 * 1024 * 10);
            return upload;
        }
        public static String uploadParseRequest(ServletFileUpload upload,HttpServletRequest request,String uploadpath) throws IOException, FileUploadException {
            String msg = "";
            //3、处理上传文件
            //把前端的请求解析，封装成一个FileItem对象
            List<FileItem> fileItems = upload.parseRequest(request);
            for (FileItem fileItem : fileItems) {
                if (fileItem.isFormField()){ //判断是普通表单还是带文件的表单
                    //getFieldName指的是前端表单控件的name
                    String name = fileItem.getFieldName();
                    String value = fileItem.getString("UTF-8");//处理乱码
                    System.out.println(name+":"+value);
                }else {//判断它是带文件的表单

                    //======================处理文件=======================//
                    //拿到文件的名字
                    String uploadFileName = fileItem.getName();
                    System.out.println("上传的文件名："+uploadFileName);
                    //如果文件名不合法就终止方法
                    if (uploadFileName.trim().equals("")) continue;
                    //获得上传的文件名，例如/img/girl/ooa.jpg,只需要ooa.jpg
                    String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/") + 1);
                    //获得文件的后缀名
                    String fileExtName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1);
                    /*
                     * 如果后缀名 fileExtName 不是我们需要的
                     *就直接return，不处理，告诉用户类型不对
                     * */
                    System.out.println("文件信息【文件名："+fileName+"文件类型："+fileExtName+"】");
                    // 可以使用java.util.UUID(唯一通用识别码)来保证文件名的统一;UUID.randomUUID()可以随机生成一个唯一识别的通用码
                    // 网络传输中的东西都需要序列化,序列化就要实现java.io.Serializable接口;这个接口是一个标记接口,即没有方法的接口,通过JVM本地方法栈来识别实现这个接口的类
                    String uuidFileName = UUID.randomUUID().toString();

                    //=======================传输文件=========================//
                    //获得文件上传的流
                    InputStream inputStream = fileItem.getInputStream();
                    //创建一个文件输出流
                    FileOutputStream fos = new FileOutputStream(uploadpath + "/" + uuidFileName +"."+ fileExtName);
                    //创建一个缓冲区
                    byte[] buffer = new byte[1024 * 1024];
                    //判断是否读取完毕
                    int len;
                    //如果大于0，说明还存在数据
                    while ((len=inputStream.read(buffer))>0){
                        fos.write(buffer,0,len);
                    }
                    //关闭流
                    fos.close();
                    inputStream.close();
                    msg = "文件上传成功！";
                    fileItem.delete();//上传成功，清除临时文件
                }
            }
            return msg;
        }
}

maven项目查看上传的文件:在~\Tomcat\apache-tomcat-9.0.62\webapps\ROOT\WEB-INF\Upload中,每个上传的文件的文件名都是一个UUID(见代码注释),不会相互重复

十八、邮件发送原理和实现

原理:

邮件服务器主要由IMAP（或POP3）服务器、SMTP服务器和File System组成，分别负责邮件的接受、发送和存储与管理。
简单附件: 纯文本邮件; 复杂邮件: 纯文本邮件+附件

实现:

导包
JavaMail API (compat)和JavaBeans™ Activation Framework
前者是为Java开发实现邮件发送和接受功能而提供的一套标准开发包, 它支持一些常用的邮件协议, 如SMTP, POP3, IMAP, MIME(多用途互联网邮件扩展类型, 用于支持附件功能)等
发送简单邮件

import com.sun.mail.util.MailSSLSocketFactory;

import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import java.util.Properties;

//发送一封简单的邮件
public class MailDamo01 {
    public static void main(String[] args) throws Exception {
        Properties prop=new Properties();
        prop.setProperty("mail.host","smtp.qq.com");///设置QQ邮件服务器
        prop.setProperty("mail.transport.protocol","smtp");///邮件发送协议
        prop.setProperty("mail.smtp.auth","true");//需要验证用户密码
        
        //QQ邮箱需要设置SSL加密
        MailSSLSocketFactory sf=new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.smtp.ssl.enable","true");
        prop.put("mail.smtp.ssl.socketFactory",sf);

        //使用javaMail发送邮件的5个步骤
        //1.创建定义整个应用程序所需要的环境信息的session对象
        //QQ才有!其他邮箱就不用
        Session session=Session.getDefaultInstance(prop, new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("[email protected]","授权码");
            }
        });
        //开启session的debug模式，这样可以在控制台查看到程序发送Email的运行状态
        session.setDebug(true);

        //2.通过session得到transport对象
        Transport ts=session.getTransport();

        //3.使用邮箱的用户名和授权码连上邮件服务器.授权码可以登录验证后获得
        ts.connect("smtp.qq.com","[email protected]","授权码");

        //4.创建邮件：写文件
        //注意需要传递session
        MimeMessage message=new MimeMessage(session);
        //指明邮件的发件人
        message.setFrom(new InternetAddress("[email protected]"));
        //指明邮件的收件人，现在发件人和收件人是一样的，那就是自己给自己发.
        message.setRecipient(Message.RecipientType.TO,new InternetAddress("[email protected]"));
        //邮件标题
        message.setSubject("发送的标题");
        //邮件的文本内容
        message.setContent("内容","text/html;charset=UTF-8");

        //5.发送邮件
        ts.sendMessage(message,message.getAllRecipients());

        //6.关闭连接
        ts.close();

    }
}

复杂邮件

package com.kuang;

import com.sun.mail.util.MailSSLSocketFactory;

import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import java.util.Properties;

public class MailDamo01 {
    public static void main(String[] args) throws Exception {
        Properties prop=new Properties();
        prop.setProperty("mail.host","smtp.qq.com");///设置QQ邮件服务器
        prop.setProperty("mail.transport.protocol","smtp");///邮件发送协议
        prop.setProperty("mail.smtp.auth","true");//需要验证用户密码
        //QQ邮箱需要设置SSL加密
        MailSSLSocketFactory sf=new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.smtp.ssl.enable","true");
        prop.put("mail.smtp.ssl.socketFactory",sf);

        //使用javaMail发送邮件的5个步骤
        //1.创建定义整个应用程序所需要的环境信息的session对象
        Session session=Session.getDefaultInstance(prop, new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("[email protected]","授权码");
            }
        });
        //开启session的debug模式，这样可以查看到程序发送Email的运行状态
        session.setDebug(true);
        //2.通过session得到transport对象
        Transport ts=session.getTransport();
        //3.使用邮箱的用户名和授权码连上邮件服务器
        ts.connect("smtp.qq.com","[email protected]","授权码");
        //4.创建邮件：写文件
        //注意需要传递session
        MimeMessage message=new MimeMessage(session);
        //指明邮件的发件人
        message.setFrom(new InternetAddress("[email protected]"));
        //指明邮件的收件人
        message.setRecipient(Message.RecipientType.TO,new InternetAddress("[email protected]"));
        //邮件标题
        message.setSubject("java发出");

        //邮件的文本内容
        //=================================准备图片数据=======================================
        MimeBodyPart image=new MimeBodyPart();
        //图片需要经过数据化的处理
        DataHandler dh=new DataHandler(new FileDataSource("D:\\CCC\\mail-java\\src\\01.jpg"));
        //在part中放入这个处理过图片的数据
        image.setDataHandler(dh);
        //给这个part设置一个ID名字
        image.setContentID("bz.jpg");
        //准备正文的数据
        MimeBodyPart text=new MimeBodyPart();
        text.setContent("这是一张正文","text/html;charset=UTF-8");
        //描述数据关系
        MimeMultipart mm=new MimeMultipart();
        mm.addBodyPart(text);
        mm.addBodyPart(image);
        mm.setSubType("related");
        //设置到消息中，保存修改
        message.setContent(mm);
        message.saveChanges();
        
        //5.发送邮件
        ts.sendMessage(message,message.getAllRecipients());
        //6.关闭连接
        ts.close();
    }
}

注意：

用户发送邮件后，可以边发送邮件边令用户跳转到“发送成功”的页面，以提高用户体验感。方法是使用多线程，其中的Servlet程序如下，其中的Sendmail类继承了Thread，它的run方法内容就是上面发送邮件的代码：

package com.kuang.servlet;

import com.kuang.pojo.User;
import com.kuang.utils.Sendmail;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class RegisterServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    	//从前端获取用户信息
        String username=req.getParameter("username");
        String password=req.getParameter("pwd");
        String email=req.getParameter("email");
        User user=new User(username,password,email);

        Sendmail send=new Sendmail(user);
        //启动线程，线程启动之后就会执行run方法来发送邮件
        send.start();

        //发送成功页面
        req.setAttribute("message","注册成功，我们已经发了一封带了注册信息的电子邮件，请查收!如网络不稳定，可能过会儿才能收到!");
        req.getRequestDispatcher( "info.jsp").forward(req,resp);
        System.out.println("success");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
}

使用Spring框架可以简化操作

你可能感兴趣的:(javaweb,maven,tomcat,servlet,java)

基于Python+Django的可视化学习系统设计与实现（毕业设计源码+技术文档+系统部署）逐梦设计 Python毕业设计实战案例 python django 课程设计 vue.js 毕业设计源码
博主简介作者简介：Java领域优质创作者、CSDN博客专家、CSDN内容合伙人、掘金特邀作者、阿里云博客专家、51CTO特邀作者、多年架构师设计经验、多年校企合作经验，被多个学校常年聘为校外企业导师，指导学生毕业设计并参与学生毕业答辩指导，有较为丰富的相关经验。期待与各位高校教师、企业讲师以及同行交流合作主要内容：Java项目、Python项目、前端项目、PHP、ASP.NET、人工智能与大数据、
Java 在运行期、源码级别和字节码级别处理的对比分析，涵盖定义、实现方式、优缺点及典型应用场景爱的叹息 Java 基础整理 java python 开发语言
以下是Java在运行期、源码级别和字节码级别处理的对比分析，涵盖定义、实现方式、优缺点及典型应用场景：1.对比维度维度运行期处理源码级别处理字节码级别处理工作阶段程序运行时动态操作编译阶段生成/修改代码编译后到运行前修改字节码实现方式反射、动态代理、JVM工具注解处理器（APT）、模板引擎ASM、Javassist、ByteBuddy修改内容对象/类的属性、方法调用源代码文件字节码（.class文
JavaScript 案例购物车《嘘》安静 javascript 前端开发语言
思路：1、获取页面元素，本练习用的表格table实现2、声明一个数组，包含自己需要渲染的内容，每个内容需要声明一个默认值，便于之后用来判断是否被勾选3、封装渲染函数：通过遍历每一个元素，判断勾选状态，如果被勾选，就直接添加选中属性，没有则正常添加。4、接着遍历元素的每一个键，并分别赋值给每一个td。5、判断合计金额，每次遍历完成后，需要把被勾选的元素单价*数量并赋值给总价的元素。6、最后直接渲染到
JavaScript 案例留言板《嘘》安静 javascript css html
思路1、设置点击事件。点击留言按钮获取本地储存并转为数组。2、判断本地储存是否有值，如果有获取最后一个元素的id，如没有就把他赋值为一个新数组，把id值赋为1.3、在判断文本框是否有值，有值才能操作。4、调用时间函数，得到当前时间，当前用户名，以及当前内容以对象的方式存入数组。5、调用渲染函数，每次调用都把留言框的值为空，让他重新获取重新渲染。6、获取本地储存的数据数组，遍历每一个元素，就创建一个
JS严格模式：全面解析与开发实践努力的小朱同学 JavaScript基础 javascript 前端面试
一、简介在某些JS代码中，开头会有一行"usestrict"，这表达什么意思呢？其实，“usestrict”是一种严格模式指令（StrictMode），是采用具有限制性JavaScript变体的一种方式，于2009年的ES5规范中首次引入，并在后续规范中不断完善。严格模式对正常的JS语法进行了限制，如：通过抛出错误来消除了一些原有静默错误；修复了一些导致JS引擎难以执行优化的缺陷，使代码运行速度更
如何设计灵活且可扩展的促销系统：策略模式的电商应用实例 !! Java设计模式必知必会 AI Agent首席体验官策略模式 java 设计模式
1.Java策略模式模式策略模式是一种行为型设计模式，它就像是一个可以随时更换的工具箱。想象一下，您是一名厨师，面对不同的食材需要使用不同的切菜工具：切肉需要用到菜刀切面团需要用到面刀切菜需要用到水果刀在策略模式中：环境类(Context)：相当于厨师本人，可以根据需要拿起不同的刀具策略接口(Strategy)：相当于所有刀具的统一规范，都有"切东西"的功能具体策略(ConcreteStrateg
AMD异步模块介绍【D＇accumulation】前端学习
基本介绍AMD（AsynchronousModuleDefinition，异步模块定义）是一种用于JavaScript模块化编程的规范，它允许JavaScript代码以异步方式加载模块及其依赖。它最初是为了解决浏览器端JavaScript代码模块化的问题，最著名的实现是RequireJS。AMD出现背景JavaScript发展初期，所有代码都写在一个.js文件里，或者通过有哪些特点AMD主要用于浏
java架构设计-COLA 芸尚非 java 开发语言
参考：https://github.com/alibaba/COLA架构要素：组成架构的重要元素结构：要素直接的关系意义：定义良好的结构，治理应用复杂度，降低系统熵值，改善混乱状态创建COLA应用：mvnarchetype:generate\-DgroupId=com.alibaba.cola.demo.web\-DartifactId=demo-web\-Dversion=1.0.0-SNAPS
Java 数组终极详解可问可问春风 java基础 java 开发语言
以下是Java数组终极详解，覆盖底层原理、操作技巧、高频陷阱及性能优化方法，帮助您全面掌握数组的精髓：一、数组核心概念速查表特性描述存储类型相同数据类型元素的连续内存块长度固定数组长度在创建时确定，不可动态扩展索引访问从0开始索引，支持随机存取（时间复杂度O(1)）内存分配数组变量存储的是堆内存中数组对象的引用地址默认值初始化int[]默认0，boolean[]默认false，对象数组默认null
LLM大模型提示工程Prompt Engineering Langchain prompt langchain 私有化大模型人工智能产品经理 ai大模型 LLM
在LLM中影响词汇的分布主要通过两种方式，一种是通过提示（Prompting），另外一种就是通过训练（Training）。提示是影响词汇分布最简单的方法，通过给LLM输入提示文本（有时会包含指令和示例）使得词汇的分布概率发生变化。以上一篇中提到的例子说明，最初的语句是“我写信给农场，希望他们送我一个宠物，他们送给我一只（）“词汇的分布如下：代码语言：javascript**复制牛0.1羊0.2狗0
领域驱动新实践：COLA框架全解析——架构设计与实战案例解析 Java进阶八股文后端
1.引言：为什么选择COLA实现DDD？——从“代码泥潭”到“领域清晰”的架构跃迁传统分层架构的痛点：当代码沦为“数据库操作说明书”在典型的MVC或三层架构中，业务逻辑常常被“撕碎”成零散的片段，散落在Service层的各个角落。以电商系统的订单管理为例，开发者可能会遇到这样的场景：java代码解读复制代码//传统Service层：贫血模型的典型代码publicclassOrderService{
用ACM模式模板刷hot100 boguboji java
面试手撕给的模板基础上写给的模板一般是下面这样把while内容删除（一般刷hot100题目输入不需要同时输入几组）第一个方法里写处理输入输出自己再写一个方法，就是力扣里的核心代码（加上static）第一个处理输入输出的方法里面调用第二块的方法importjava.util.*;publicclassMain{publicstaticvoidmain(String[]args){Scannerin=
Java Panama 项目：Java 与 AI 的融合 AI天才研究院计算 Java实战 DeepSeek R1 &大数据AI人工智能大模型人工智能 java python
JavaPanama项目：Java与AI的融合Java在AI领域的优势Java在AI领域的优势主要体现在以下几个方面：强大的生态系统：Java拥有丰富的库和框架，为AI开发提供了坚实的基础。跨平台性：Java的“一次编写，到处运行”特性，降低了AI应用的运维成本。高性能与稳定性：Java虚拟机（JVM）的优化和垃圾回收机制，确保了AI应用的高效运行和内存管理。实时数据处理能力：Java可以高效处理
WebAssembly 与 JavaScript：高性能 Web 开发的未来 vvilkim JavaScript 现代WEB技术 wasm javascript 开发语言
在现代Web开发中，性能始终是一个关键问题。随着Web应用变得越来越复杂，开发者需要更高效的工具和技术来满足用户对速度和响应能力的需求。WebAssembly（简称Wasm）正是为此而生。它是一种低级的二进制指令格式，旨在为Web提供接近原生代码的执行性能。与此同时，它与JavaScript的关系也备受关注。本文将深入探讨WebAssembly是什么，以及它与JavaScript如何协同工作。什么
Windows操作系统部署Tomcat详细讲解 web15085415935 面试学习路线阿里巴巴 windows tomcat java
Tomcat是一个开源的JavaServlet容器，用于处理JavaWeb应用程序的请求和响应。以下是关于Tomcat的用法大全：一、安装Tomcat下载访问ApacheTomcat官方网站（https://tomcat.apache.org/），根据你的操作系统（如Windows、Linux、macOS）和需求选择合适的版本进行下载。例如，对于开发环境，通常选择较新的稳定版本。安装（以Windo
详细说明脚本评估和耗时较长的任务混血哲谈性能优化
在网页性能优化中，脚本评估和耗时较长的任务是两大关键性能瓶颈。它们直接影响页面的加载速度、交互响应以及用户体验。以下是对这两个概念的详细说明及优化策略：一、脚本评估（ScriptEvaluation）1.定义脚本评估指浏览器解析（Parsing）、编译（Compiling）和执行（Executing）JavaScript代码的全过程。这一过程通常包括：解析：将文本形式的JavaScript代码转换
Tomcat升级步骤 qq_33928223 软件部署 tomcat java
以下是ApacheTomcat升级的一般步骤，具体操作可能因环境和需求有所不同，请根据实际情况进行调整：1.确定当前版本和目标版本确认当前版本:查看当前正在运行的Tomcat版本。$CATALINA_HOME/bin/version.sh选择目标版本:根据需求选择要升级到的目标版本（如从8.x到9.x或更高版本）。2.备份现有安装备份配置文件：server.xmlweb.xmlcontext.xm
使用HSDB验证Class对象和类的静态对象保存在堆中 Yuck1125 技术 java jvm
HSDB(HotspotDebugger)运行图形界面java-cp$JAVA_HOME/lib/sa-jdi.jarsun.jvm.hotspot.HSDB命令行java-cp$JAVA_HOME/lib/sa-jdi.jarsun.jvm.hotspot.CLHSDB本文使用的时命令行CLHSDB。由于HSDB会先attach进程，然后暂停进程，所以线上慎用。。。验证过程使用到的类public
JavaScript（JS）单线程影响速度 ok060 javascript 开发语言 ecmascript
js单线程影响速度在JavaScript（JS）中，单线程的本质是其执行模型的核心特点，这意味着同一时间只能执行一个任务。这种设计使得JS在处理诸如DOM操作、用户交互等任务时更为直观和安全，因为它避免了复杂的多线程并发问题，如竞态条件（raceconditions）和死锁（deadlocks）。然而，单线程的特性也确实影响了其处理大量计算或I/O密集型任务时的性能。影响速度的原因阻塞性操作：在单
Java有哪些编程技巧？ java
Java编程技巧：提升效率与质量的实用指南在Java编程中，掌握一些高效的编程技巧不仅可以提高开发效率，还能提升代码的可读性、可维护性和性能。以下是一些实用的Java编程技巧，供开发者参考和应用。一、代码优化技巧（一）合理使用数据类型选择合适的数据类型：根据实际需求选择合适的数据类型。例如，如果只需要存储整数，且数值范围较小，可以使用int而不是long，以节省内存。使用包装类时需谨慎：Java的
hsdb查看Tomcat注解的实例 ok060 tomcat java hsdb
‌一、HSDB查看Tomcat注解的实例步骤‌‌1.附加Tomcat进程‌‌获取Tomcat进程ID‌：使用jps-l命令查找Tomcat的PID（如12345），确保Tomcat处于运行状态‌38。‌启动HSDB‌：jhsdbhsdb--pid12345‌2.定位目标类‌‌打开ClassBrowser‌：在HSDB界面点击‌Tools→ClassBrowser‌，输入目标类名（如com.exam
Java面试黄金宝典12 ylfhpy Java面试黄金宝典 java 面试开发语言
1.什么是Java类加载机制定义Java类加载机制是Java程序运行时的关键环节，其作用是把类的字节码文件（.class文件）加载到Java虚拟机（JVM）中，并且将字节码文件转化为JVM能够识别的类对象。整个类加载过程主要包含加载、连接（验证、准备、解析）和初始化三个阶段。原理加载阶段：此阶段会通过类的全限定名来获取定义该类的二进制字节流。获取途径较为多样，既可以从本地文件系统读取，也能从网络下
MybatisPlus 伶星37 spring boot 后端
代码部分添加依赖该代码添加位置：就是在springboot配置文件里面的pom.xml里面要添加的东西对新手说的话，如果这一步没有看懂的话，可以去看一下基础，否则这样的话不能做到理解学习//mybatis-plus的一个插件com.baomidoumybatis-plus-boot-starter3.4.2//这个是关于mysql的一种依赖mysqlmysql-connector-java5.1.
JVM 类加载器之间的层次关系，以及类加载的委托机制冰糖心书房 JVM 2025 Java面试系列 java jvm
JVM类加载器之间存在一种层次关系，通常被称为双亲委派模型(ParentDelegationModel)。这种层次关系和委托机制是Java类加载机制的核心，对于保证Java程序的安全性和避免类冲突至关重要。1.类加载器的层次关系:JVM中的类加载器（ClassLoader）主要分为以下几种，它们之间存在自顶向下的层次关系（父子关系，但不是继承关系，而是组合关系）：启动类加载器(BootstrapC
Nacos Server 的启动入口在哪里？启动参数有哪些？冰糖心书房 Nacos源码系列服务发现 java
一、NacosServer启动入口NacosServer的启动入口位于nacos-server模块的com.alibaba.nacos.Nacos类。主类:com.alibaba.nacos.Nacos主方法:publicstaticvoidmain(String[]args)当运行NacosServer的启动脚本(startup.sh或startup.cmd)时，脚本最终会执行java命令，并指
React Native：跨平台移动应用开发的强大框架冬冬小圆帽 react native react.js javascript
ReactNative介绍ReactNative是由Facebook开发并开源的一款基于JavaScript和React的跨平台移动应用开发框架。它允许开发者使用React的语法和组件模型来构建原生移动应用（iOS和Android）。ReactNative的核心思想是“LearnOnce,WriteAnywhere”，即学习一次，编写多端应用。1.核心特点跨平台开发：使用JavaScript和Re
java集合数据复制到另外一个集合 hamish-wu Java
文章目录Lsit中数据复制问题1.1浅拷贝1.2深拷贝1.3最终结论Lsit中数据复制问题这是由一道开放式面试题引发的文章，题目：加入内存足够大，一个集合中有100万条数据，怎么高效的把集合中的数据复制到另外一个集合1.1浅拷贝java中复制分为浅拷贝和深拷贝如果考察浅拷贝：直接使用clone方法System.out.println("测试开始时");Lista=newArrayList(1000
Java 大视界 -- Java 大数据在智慧农业精准灌溉与施肥决策中的应用（144）青云交大数据新视界 Java 大视界 java 大数据智慧农业精准灌溉施肥决策数据分析机器学习
亲爱的朋友们，热烈欢迎来到青云交的博客！能与诸位在此相逢，我倍感荣幸。在这飞速更迭的时代，我们都渴望一方心灵净土，而我的博客正是这样温暖的所在。这里为你呈上趣味与实用兼具的知识，也期待你毫无保留地分享独特见解，愿我们于此携手成长，共赴新程！一、欢迎加入【福利社群】点击快速加入：青云交灵犀技韵交响盛汇福利社群点击快速加入2：2024CSDN博客之星创作交流营（NEW)二、本博客的精华专栏：大数据新视
Java 大视界 -- 基于 Java 的大数据机器学习模型的多模态融合技术与应用（143）青云交大数据新视界 Java 大视界 java 大数据机器学习多模态融合智能安防智能客服数据处理
亲爱的朋友们，热烈欢迎来到青云交的博客！能与诸位在此相逢，我倍感荣幸。在这飞速更迭的时代，我们都渴望一方心灵净土，而我的博客正是这样温暖的所在。这里为你呈上趣味与实用兼具的知识，也期待你毫无保留地分享独特见解，愿我们于此携手成长，共赴新程！一、欢迎加入【福利社群】点击快速加入：青云交灵犀技韵交响盛汇福利社群点击快速加入2：2024CSDN博客之星创作交流营（NEW)二、本博客的精华专栏：大数据新视
vscode python 入门教程(二) vscode使用gti 管理代码 hamish-wu vscode ide 编辑器
vscode代码管理需要用管道git的命令，这点和idea的代码管理区别比较大。作为java开发需要自己熟悉适应一下。一、GitHub新建一个仓库过程略二、本地git项目初始化gitinitvscode中可以看到文件状态gitstatus使用gitremote命令吧本地git仓库和远程git仓库链接起来[email protected]提交代码gitcommit-m"评论
java的(PO,VO,TO,BO,DAO,POJO) Cb123456 VO TO BO POJO DAO
转: http://www.cnblogs.com/yxnchinahlj/archive/2012/02/24/2366110.html ------------------------------------------------------------------- O/R Mapping 是 Object Relational Mapping（对象关系映
spring ioc原理（看完后大家可以自己写一个spring） aijuans spring
最近，买了本Spring入门书：spring In Action 。大致浏览了下感觉还不错。就是入门了点。Manning的书还是不错的，我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍。又一次接受了IOC 、DI、AOP等Spring核心概念。先就IOC和DI谈一点我的看法。IO
MyEclipse 2014中Customize Persperctive设置无效的解决方法 Kai_Ge MyEclipse2014
高高兴兴下载个MyEclipse2014，发现工具条上多了个手机开发的按钮，心生不爽就想弄掉他！结果发现Customize Persperctive失效！！有说更新下就好了，可是国内Myeclipse访问不了，何谈更新... so~这里提供了更新后的一下jar包，给大家使用！ 1、将9个jar复制到myeclipse安装目录\plugins中 2、删除和这9个jar同包名但是版本号较
SpringMvc上传 120153216 springMVC
@RequestMapping(value = WebUrlConstant.UPLOADFILE) @ResponseBody public Map<String, Object> uploadFile(HttpServletRequest request,HttpServletResponse httpresponse) { try { //
Javascript----HTML DOM 事件何必如此 JavaScript html Web
HTML DOM 事件允许Javascript在HTML文档元素中注册不同事件处理程序。事件通常与函数结合使用，函数不会在事件发生前被执行！注：DOM：指明使用的 DOM 属性级别。 1.鼠标事件属性
动态绑定和删除onclick事件 357029540 JavaScript jquery
因为对JQUERY和JS的动态绑定事件的不熟悉，今天花了好久的时间才把动态绑定和删除onclick事件搞定!现在分享下我的过程。在我的查询页面，我将我的onclick事件绑定到了tr标签上同时传入当前行(this值)参数，这样可以在点击行上的任意地方时可以选中checkbox，但是在我的某一列上也有一个onclick事件是用于下载附件的，当
HttpClient|HttpClient请求详解 7454103 apache 应用服务器网络协议网络应用 Security
HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。本文首先介绍 HTTPClient，然后根据作者实际工作经验给出了一些常见问题的解决方法。HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需
递归逐层统计树形结构数据 darkranger 数据结构
将集合递归获取树形结构: /** * * 递归获取数据 * @param alist:所有分类 * @param subjname:对应统计的项目名称 * @param pk:对应项目主键 * @param reportList: 最后统计的结果集 * @param count:项目级别 */ public void getReportVO(Arr
访问WEB-INF下使用frameset标签页面出错的原因 aijuans struts2
<frameset rows="61,*,24" cols="*" framespacing="0" frameborder="no" border="0">
MAVEN常用命令 avords
Maven库： http://repo2.maven.org/maven2/ Maven依赖查询： http://mvnrepository.com/ Maven常用命令： 1. 创建Maven的普通java项目： mvn archetype:create -DgroupId=packageName
PHP如果自带一个小型的web服务器就好了 houxinyou apache 应用服务器 Web PHP 脚本
最近单位用PHP做网站，感觉PHP挺好的，不过有一些地方不太习惯，比如，环境搭建。PHP本身就是一个网站后台脚本，但用PHP做程序时还要下载apache，配置起来也不太很方便，虽然有好多配置好的apache+php+mysq的环境，但用起来总是心里不太舒服，因为我要的只是一个开发环境，如果是真实的运行环境，下个apahe也无所谓，但只是一个开发环境，总有一种杀鸡用牛刀的感觉。如果php自己的程序中
NoSQL数据库之Redis数据库管理(list类型) bijian1013 redis 数据库 NoSQL
3.list类型及操作 List是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等，操作key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。我们可以通过push、pop操作从链表的头部或者尾部添加删除元素，这样list既可以作为栈，又可以作为队列。 &nbs
谁在用Hadoop？ bingyingao hadoop 数据挖掘公司应用场景
Hadoop技术的应用已经十分广泛了，而我是最近才开始对它有所了解，它在大数据领域的出色表现也让我产生了兴趣。浏览了他的官网，其中有一个页面专门介绍目前世界上有哪些公司在用Hadoop，这些公司涵盖各行各业，不乏一些大公司如alibaba,ebay,amazon,google,facebook,adobe等，主要用于日志分析、数据挖掘、机器学习、构建索引、业务报表等场景,这更加激发了学习它的热情。
【Spark七十六】Spark计算结果存到MySQL bit1129 mysql
package spark.examples.db import java.sql.{PreparedStatement, Connection, DriverManager} import com.mysql.jdbc.Driver import org.apache.spark.{SparkContext, SparkConf} object SparkMySQLInteg
Scala: JVM上的函数编程 bookjovi scala erlang haskell
说Scala是JVM上的函数编程一点也不为过，Scala把面向对象和函数型编程这两种主流编程范式结合了起来，对于熟悉各种编程范式的人而言Scala并没有带来太多革新的编程思想，scala主要的有点在于Java庞大的package优势，这样也就弥补了JVM平台上函数型编程的缺失，MS家.net上已经有了F#，JVM怎么能不跟上呢？对本人而言
jar打成exe bro_feng java jar exe
今天要把jar包打成exe，jsmooth和exe4j都用了。遇见几个问题。记录一下。两个软件都很好使，网上都有图片教程，都挺不错。首先肯定是要用自己的jre的，不然不能通用，其次别忘了把需要的lib放到classPath中。困扰我很久的一个问题是，我自己打包成功后，在一个同事的没有装jdk的电脑上运行，就是不行，报错jvm.dll为无效的windows映像，如截图最后发现
读《研磨设计模式》-代码笔记-策略模式-Strategy bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化简单理解： 1、将不同的策略提炼出一个共同接口。这是容易的，因为不同的策略，只是算法不同，需要传递的参数
cmd命令值cvfM命令 chenyu19891124 cmd
cmd命令还真是强大啊。今天发现jar -cvfM aa.rar @aaalist 就这行命令可以根据aaalist取出相应的文件例如：在d：\workspace\prpall\test.java 有这样一个文件，现在想要将这个文件打成一个包。运行如下命令即可比如在d：\wor
OpenJWeb(1.8) Java Web应用快速开发平台 comsci java 框架 Web 项目管理企业应用
OpenJWeb(1.8) Java Web应用快速开发平台的作者是我们技术联盟的成员，他最近推出了新版本的快速应用开发平台 OpenJWeb(1.8)，我帮他做做宣传 OpenJWeb快速开发平台以快速开发为核心，整合先进的java 开源框架，本着自主开发+应用集成相结合的原则，旨在为政府、企事业单位、软件公司等平台用户提供一个架构透
Python 报错：IndentationError: unexpected indent daizj python tab 空格缩进
IndentationError: unexpected indent 是缩进的问题，也有可能是tab和空格混用啦 Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且在Python语言里，缩进而非花括号或者某种关键字，被用于表示语句块的开始和退出。增加缩进表示语句块的开
HttpClient 超时设置 dongwei_6688 httpclient
HttpClient中的超时设置包含两个部分： 1. 建立连接超时，是指在httpclient客户端和服务器端建立连接过程中允许的最大等待时间 2. 读取数据超时，是指在建立连接后，等待读取服务器端的响应数据时允许的最大等待时间在HttpClient 4.x中如下设置： HttpClient httpclient = new DefaultHttpC
小鱼与波浪 dcj3sjt126com
一条小鱼游出水面看蓝天，偶然间遇到了波浪。　　小鱼便与波浪在海面上游戏，随着波浪上下起伏、汹涌前进。　　小鱼在波浪里兴奋得大叫：“你每天都过着这么刺激的生活吗？简直太棒了。”　　波浪说：“岂只每天过这样的生活，几乎每一刻都这么刺激！还有更刺激的，要有潮汐变化，或者狂风暴雨，那才是兴奋得心脏都会跳出来。”　　小鱼说：“真希望我也能变成一个波浪，每天随着风雨、潮汐流动，不知道有多么好！”　　很快，小鱼
Error Code: 1175 You are using safe update mode and you tried to update a table dcj3sjt126com mysql
快速高效用：SET SQL_SAFE_UPDATES = 0；下面的就不要看了！今日用MySQL Workbench进行数据库的管理更新时，执行一个更新的语句碰到以下错误提示： Error Code: 1175 You are using safe update mode and you tried to update a table without a WHERE that
枚举类型详细介绍及方法定义 gaomysion enum javaee
转发 http://developer.51cto.com/art/201107/275031.htm 枚举其实就是一种类型，跟int, char 这种差不多，就是定义变量时限制输入的，你只能够赋enum里面规定的值。建议大家可以看看，这两篇文章，《java枚举类型入门》和《C++的中的结构体和枚举》，供大家参考。枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum
Merge Sorted Array hcx2013 array
Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array. Note:You may assume that nums1 has enough space (size that is
Expression Language 3.0新特性 jinnianshilongnian el 3.0
Expression Language 3.0表达式语言规范最终版从2013-4-29发布到现在已经非常久的时间了；目前如Tomcat 8、Jetty 9、GlasshFish 4已经支持EL 3.0。新特性包括：如字符串拼接操作符、赋值、分号操作符、对象方法调用、Lambda表达式、静态字段/方法调用、构造器调用、Java8集合操作。目前Glassfish 4/Jetty实现最好，对大多数新特性
超越算法来看待个性化推荐 liyonghui160com 超越算法来看待个性化推荐
一提到个性化推荐，大家一般会想到协同过滤、文本相似等推荐算法，或是更高阶的模型推荐算法，百度的张栋说过，推荐40%取决于UI、30%取决于数据、20%取决于背景知识，虽然本人不是很认同这种比例，但推荐系统中，推荐算法起的作用起的作用是非常有限的。就像任何
写给Javascript初学者的小小建议 pda158 JavaScript
　　一般初学JavaScript的时候最头痛的就是浏览器兼容问题。在Firefox下面好好的代码放到IE就不能显示了，又或者是在IE能正常显示的代码在firefox又报错了。　　如果你正初学JavaScript并有着一样的处境的话建议你：初学JavaScript的时候无视DOM和BOM的兼容性，将更多的时间花在了解语言本身（ECMAScript）。只在特定浏览器编写代码（Chrome/Fi
Java 枚举 ShihLei java enum 枚举
注：文章内容大量借鉴使用网上的资料，可惜没有记录参考地址，只能再传对作者说声抱歉并表示感谢！一基础 1）语法枚举类型只能有私有构造器（这样做可以保证客户代码没有办法新建一个enum的实例）枚举实例必须最先定义 2）特性 &nb
Java SE 6 HotSpot虚拟机的垃圾回收机制 uuhorse java HotSpot GC 垃圾回收 VM
官方资料，关于Java SE 6 HotSpot虚拟机的garbage Collection，非常全，英文。 http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html Java SE 6 HotSpot[tm] Virtual Machine Garbage Collection Tuning &

JavaWeb

JavaWeb

目录

一、JavaWeb

4. 一个网站访问的过程：

二、Maven

idea技巧之Ctrl+Shift+/快速添加注释

三、Servlet

idea技巧之alt+fn+prt sc或alt+Ins在web.xml中快速插入和功能块

idea技巧之快捷键alt+enter：先输入一个返回变量的方法名，或new一个类的对象，然后按快捷键可以补充该对象的声明语句

四、ServletContext

重要技巧之.properties文件

classpath

五、HttpServletResponse（extends ServletResponse）

重定向和转发的区别

六、HttpServletRequest

七、会话

1. Cookie

2. Session

idea技巧之 packege分包与取消分包的方式：

idea技巧之快速自动生成getter、setter等方法，或在xml中快速生成servlet等 代码块：alt+insert

八、JSP

1. 基本原理

2. 基础语法

3. JSP指令

4. 九大内置对象

5. JSP标签、JSTL标签、EL表达式

九、JavaBean

重要技巧之Lombok

十、MVC三层架构

架构思想：

十一、Filter（重点）

idea技巧之快速添加web框架支持：

十二、监听器

十三、过滤器、监听器常见应用

重要技巧之静态static变量的使用:

十四、回顾JDBC

idea技巧之快速键入main()方法的声明

idea技巧之快速键入“System.out.println()”

重要技巧之junit单元测试可以对某个方法单独运行而无需main()方法：

十五、Ajax

十六、项目搭建实战（超市订单管理系统SMBMS）

1、准备工作

功能实现阶段——先画出功能的MVC三层架构，再从底向上逐层实现功能：

2、登录功能实现

View层

Modle层

DAO层

idea技巧之快速键入某个参数的非空判断语句和@NotNull插件

service层

重要技巧之方便地对底层属性和方法进行调用

Controller/Servlet层

3. 登录功能优化

4. 密码修改功能实现

View层

Model层

DAO层

Service层

Controller/Servlet层

重要技巧之Servlet复用

5. 密码修改功能优化（Ajax）

6. 用户管理功能实现

View层

Modle层

DAO层

Service层

Controller/Servlet层

十七、文件上传

十八、邮件发送原理和实现

你可能感兴趣的:(javaweb,maven,tomcat,servlet,java)

idea技巧之快速自动生成getter、setter等方法，或在xml中快速生成servlet等代码块：alt+insert