一，配置tomcat

Tomcat配置

二，Servlet

1.什么叫Servlet

Servlet就是sun公司开发动态web的一门技术
Sun在这些APi中提供一个接口叫做：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：
编写一个类，实现Serlet接口
把开发好java类部署到web服务器中。
把实现了Servlet接口的Java程序叫做，Servlet

2.创建第一个Servlet

1.导包

java创建servlet，首先需要导入javax.servlet-api这个jar包
对应的maven依赖：

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>

2.创建一个java类，继承HttpServlet

import java.io.*;
import javax.servlet.ServletException;
import javax.servlet.http.*;

public class HelloServlet extends HttpServlet {
// 重写他的doGet和doPost方法
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
   }
   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
   }
}

这样一个空的servlet就创建完成了

3.配置web.xml文件

要想该servlet能发挥它的作用我们就需要给它在web.xml注册它对应的servlet

    <servlet>
        <servlet-name>该servlet的名字</servlet-name>
        <servlet-class>该servlet所在的项目路径</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>与上面的名字对应</servlet-name>
        <url-pattern>访问的路径</url-pattern>
    </servlet-mapping>

例如：

    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.example.demo_01.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello_servlet</url-pattern>
        <!--  注意这里的必须写上‘/’，他代表当前的web项目路径      -->
    </servlet-mapping>

一个servlet可以对应多个映射路径，即:servlet-mapping

    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello_servlet</url-pattern>
    </servlet-mapping>
     <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello1</url-pattern>
    </servlet-mapping>
     <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello2</url-pattern>
    </servlet-mapping>

只要名字一致，他们都代表着同一个servlet
补充说明：/*代表该路径下得所有路径
web.xml文件可配置内容总结1.servlet，监听器，过滤器都需要配置对应的servlet

3.ServleContext

1.什么是ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用；
本质：servlet的一个对象
特性：全局唯一；
作用：存放全局数据，获取web应用中的文件，配置初始哈参数等等

2.常用方法

sc.setAttribute(String key,Object value);
sc.addFilter(String s1,Filter f);
sc.getAttribute(String key);
sc.setInitParameter(String s1,String s2);
sc.getInitParameter(String s1);
getRequestDispatcher("路径").forward(req,resp);
getResourceAsStream(String Address);

2.创建一个ServletContext的简单使用案例

1、共享数据

        ServletContext context = this.getServletContext();

        String username = "某某"; //数据
        context.setAttribute("username",username);//一键值对的形式保存

2、获取web.xml中初始化参数

    <context-param>
        <param-name>url</param-name>
        <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
    </context-param>

    ServletContext context = this.getServletContext();
    String url = context.getInitParameter("url");

3,请求转发

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);
}

4.获取资源绑定

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.Properties;
import java.util.ResourceBundle;

public class HelloServletContext extends HttpServlet {

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //this.getInitParameter()   获取初始化参数
        //this.getServletConfig()   获取Servlet配置
        //this.getServletContext()  获取Servlet上下文（ServletContext）
        //上面三个方法为了解内容
        ServletContext sc = this.getServletContext();//创建ServletContext容器
        //获取资源文件内容
        //方式一：（需要处理乱码）
        //this.getServletContext().getResourceAsStream("/WEB-INF/classes/ServletContextBox.properties");
        InputStream is = sc.getResourceAsStream("/WEB-INF/classes/ServletContextBox.properties");
        Properties prop = new Properties() ;
        prop.load(is);
        String name = prop.getProperty("name");
        sc.setAttribute("username",name); //将一个数据保存在了ServletContext中，键：username 。值:李江
    }
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

4.HttpServletRequest

1.什么是HttpServletRequest?

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

2.HttpServletRequest的常用方法

		HttpServletRequest req;
        req.getParameter(String key);//(最常用)
        req.getParameterValues(String key);
        req.getInputStream();
        req.getSession();
        req.getContextPath();
        req.getCookies();
        req.setCharacterEncoding(String encodingName);
        req.setAttribute(String key,Object value);//(最常用)
        req.getRequestDispatcher("路径").forward(req,resp);

3.请求转发

特点：url不发生跳转 状态码 ：307

req.getRequestDispatcher("路径").forward(req,resp);//request对象请求转发

5.HttpServletResponse

1.什么是HttpServletResponse？

web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest
对象，代表响应的一个HttpServletResponse；
作用：用于响应客户端发来的请求

2.常用代码

resp.getWriter();//获取输出流
        ServletOutputStream getOutputStream() throws IOException;//获取输出流
        PrintWriter getWriter() throws IOException;//获取输出流
        void setHeader(String var1, String var2);//设置响应头信息
        void setContentType(String var1);//设置文本的响应类型
        void setDateHeader(String var1, long var2);
        void setCharacterEncoding(String var1);
        void addCookie(Cookie var1);
        void sendRedirect(String var1) throws IOException;//重定向需要加当前项目名

3.重定向

resp.sendRedirect("路径");//重定向需要加当前项目名

特点：url发生跳转 状态码 ：302

6.Cookie

1.什么是cookie？

cookie类似于服务器发给客户的通行证，客户拥有该cookie，便有权利做某些事，响应时添加resp.addCookie(cookie)；

2.创建一个cookie

Cookie cookie = new Cookie("key","value");

3.常用方法

       public void setMaxAge(int expiry)//设置cookie的有效期,单位为秒
       public String getName();//得到cookie的key
       public String getValue();

4.cookie特点

cookie：一般会保存在本地的 用户目录下 appdata；

1.一个网站cookie是否存在上限
2.一个Cookie只能保存一个信息
3.一个web站点可以给浏览器发送多个cookie，最多存放20个cookie；
4.Cookie大小有限制4kb；
5.300个cookie浏览器上限

删除Cookie：
不设置有效期，关闭浏览器，自动失效，即：设置有效期时间为 0 ；

7.Session

1.什么事session？

服务器会给每一个用户（浏览器）创建一个Seesion对象；
一个Seesion独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
用户登录之后，整个网站它都可以访问！–> 保存用户的信息；保存购物车的信息……
session类似于服务器给客户做了登记

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

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

2，Session对象

获取session

HttpSession session = req.getSession();

添加一个session属性

//session.setAttribute("key",value);
void setAttribute(String var1, Object var2);

移除一个session属性

//session.removeAttribute("key");
void removeAttribute(String var1);

销毁session

void invalidate();
//session.invalidate();

在web.xml文件中配置session属性

<!--设置Session默认的失效时间-->
<session-config>
    <!--15分钟后Session自动失效，以分钟为单位-->
    <session-timeout>15</session-timeout>
</session-config>

3.session常用方法

boolean isNew();//判断session是不是新建的
String getId();//获取session的ID
void setAttribute(String var1, Object var2);
void removeAttribute(String var1);
void invalidate();

8.监听器Listener

1.什么是监听器？

web应用中一直存在，处理某些事情发生的状况

2.监听器的应用

监听网站在线人数

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class Listener implements HttpSessionListener {
    //统计网站在线人数 ： 统计session
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();

        System.out.println(se.getSession().getId());

        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if (onlineCount==null){
            onlineCount = 1;
        }else {
            int count = onlineCount;
            onlineCount = count + 1;
        }
        ctx.setAttribute("OnlineCount",onlineCount);

    }

    //销毁session监听
    //一旦销毁Session就会触发一次这个事件！
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if (onlineCount==null){
            onlineCount = 0;
        }else {
            int count = onlineCount;
            onlineCount = count - 1;
        }

        ctx.setAttribute("OnlineCount",onlineCount);
    }
}

3.注册监听器

在web.xml中注册监听器

<!--注册监听器-->
<listener>
    <listener-class>"监听器的路径"</listener-class>
</listener>

9.过滤器Filter

1.过滤器作用

比如 Shiro安全框架技术就是用Filter来实现的
Filter：过滤器 ，用来过滤网站的数据；

处理中文乱码
登录验证….

2.过滤器的简单应用

过滤乱码

import javax.servlet.*;
import java.io.IOException;
public class SimpleFilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器初始化");
    }
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");//处理请求的乱码
        servletResponse.setCharacterEncoding("utf-8");//处理响应的乱码
        servletResponse.setContentType("text/html;charset=utf-8");//设置响应类型
    }
    public void destroy() {
        System.out.println("过滤器销毁");
    }
}

3.注册过滤器

与注册servlet类似

 <filter>
       <filter-name>文件名称</filter-name>
       <filter-class>文件路径</filter-class>
   </filter>
   <filter-mapping>
       <filter-name>CharacterEncodingFilter</filter-name>
       <url-pattern>文件过滤路径（需要过滤哪些路径下的文件）</url-pattern>
       <!-- 例如/servlet 表示只要是 /servlet的任何请求，会经过这个过滤器-->
       <!--/*(表示过滤所有)-->

   </filter-mapping>

注意事项：
1.导包：注意是import javax.servlet.Filter;
2.过滤器在服务器创建时开启，在服务器销毁时关闭

小总结

####1. web.xml可配置的属性
1.配置servlet

    <servlet>
        <servlet-name>servlet名称</servlet-name>
        <servlet-class>该servlet所在路径</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>servlet名称</servlet-name>
        <url-pattern>映射路径/访问路径（注意加'/'）</url-pattern>
    </servlet-mapping>

2.配置session

    <!--设置Session默认的失效时间-->
    <session-config>
        <!--15分钟后Session自动失效，以分钟为单位-->
        <session-timeout>15</session-timeout>
    </session-config>
    <filter>

3.配置过滤器

    <filter>
        <filter-name>过滤器名称</filter-name>
        <filter-class>该过滤器所在路径</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>过滤器名称（与上面对应）</filter-name>

        <url-pattern>需要过滤的路径（注意加 '/'）</url-pattern>
    </filter-mapping>

4.配置监听器

    <listener>
        <listener-class>该监听器的路径</listener-class>
    </listener>

5.配置欢迎页

    <welcome-file-list>
        <welcome-file>该欢迎页的路径</welcome-file>
    </welcome-file-list>

6.配置错误页面

    <error-page>
    <!--错误编码： 404 500...-->
    <error-code>错误编码</error-code>
    <location>发生该错误时访问的页面路径</location>
    </error-page>

10.JSP

1.什么是JSP

Java Server Pages ： Java服务器端页面，也和Servlet一样，用于动态Web技术！

最大的特点：

写JSP就像在写HTML

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

2.JSP执行原理

浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！
JSP最终也会被转换成为一个Java类！
JSP 本质上就是一个Servlet
JSP用到的各种标签最终都会转换为对应的java代码
IDEA中使用Tomcat的会在IDEA的tomcat中生产一个work目录，里面存放了JSP转换后的页面

3.JSP九大内置对象

PageContext 存东西
Request 存东西
Response
Session 存东西
Application 本质：ServletContext, 存东西
config 本质：SerlvetConfig
out，输出流
page ，不用了解
exception

4.常用的属性设置作用域

pageContext.setAttribute("name1","1号"); //保存的数据只在一个页面中有效
request.setAttribute("name2","2号"); //保存的数据只在一次请求中有效，请求转发会携带这个数据
session.setAttribute("name3","3号"); //保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
application.setAttribute("name4","4号");  //保存的数据只在服务器中有效，从打开服务器到关闭服务器

注意：pageContext.findAttribute(String key)方法在寻找元素时的寻找顺序:
page->request->session->application

使用案例：
1.request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！

2.session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；

3.application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据；

5.JSP基本语法

任何语言都有自己的语法，JAVA中有。 JSP 作为java技术的一种应用，它拥有一些自己扩充的语法（了解即可！），Java所有语法都支持

1.<% 此处写java代码 %> 作用：原封不动的转成java代码

2.<%= 此处写要输出的变量或者表达式 =%> 作用：用来将程序的输出，输出到客户端

3.<%! 此处写要声明的成员变量 %> 作用：在JSP生成Java的类中定义成员变量！（其他的，会被生成到_jspService方法中）

4.<%- 此处写JSP注释 -%> 作用：注释，不会被编译到HTML文件中，JSP中的HTML注释会被保留到HTML文件中

6.JSP指令

1.<%@page args.... %>作用配置文件的一些属性
2.<%@include file="文件路径" %>作用：将两个页面合二为一，成为一个页面
3.<%@ page import="java.util.ArrayList" %> 作用 ：导入包

7.EL表达式：

EL表达式：${ }
作用： 1.获取数据

2.执行运算，调用方法

3.获取web开发的常用对象
注意：EL，JSP，JSTL标签需要导入jstl，standard和两个jar包，并且在Tomcat的lib目录中导入这两个包
对应的Maven依赖：

<!-- JSTL表达式的依赖 -->
<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
</dependency>
<!-- standard标签库 -->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

8.JSP常用标签

1.<jsp:include page = "/文件路径"/>    **作用：拼接页面，页面实质上还是两个**

2.<jsp:forward page="/文件路径">         **作用：请求转发**
   3.<jsp:param name="name" value="kuangshen"></jsp:param>  作用：设置转发或其他情况时携带的参数
     <jsp:param name="age" value="12"></jsp:param>
</jsp:forward>

4.<jsp:useBean id="people" beanName="People">  **作用：创建javabea，相当于一个实体类，id 写该类的对象名称，beanName写类名**
  5.<jsp:setProperty name="id" property="3">
    </jsp:setProperty>  **作用设置在该java类中对象的属性id，并赋值为3**
</jsp:useBean>

注意：不能随便修改为自结束标签，可能会报错

9.JSTL常用标签

JSTL标签使用时需要导入外部库
<%@ taglib prefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>

核心标签：

1.``<c:if test = "条件" 需要做的事></c:if>``   作用：条件判断
2.``<c:out value = 输出内容/>  ``           作用：输出value
3.``<c:set var="score" value=值/> ``      作用：定义局部变量

4.<c:choose>                           作用：相当于java中的switch

<c:when test="条件" >			作用 choose的子标签，符合条件时做某事
                符合条件时做的事情
</c:when>
<c:when test=值 >
                符合条件时做的事情
</c:when>
</c:choose>

5.<c:forEach var = "每一次遍历出来的变量"，items= "要遍历的对象">  
作用：遍历数组内容
可设置的参数
(var:每一次遍历出来的变量
items:要遍历的对象,
begin:哪里开始
end:到哪里
step:步长)
            需要做的事
</c:forEach

11.JavaBean

实体类

JavaBean有特定的写法：

必须要有一个无参构造
属性必须私有化
必须有对应的get/set方法；
一般用来和数据库的字段做映射 ORM；

ORM ：对象关系映射

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

12.MVC三层架构

1.什么是MVC三层架构？

Model View Controller 模型、视图、控制器

2.以前的架构

用户直接访问控制层，控制层就可以直接操作数据库；
servlet–CRUD–>数据库

弊端：程序十分臃肿，不利于维护

servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码

架构：没有什么是加一层解决不了的！
程序猿调用
↑
JDBC （实现该接口）
↑
Mysql Oracle SqlServer …（不同厂商）

3.MVC三层架构

Model：
1.业务处理 ：业务逻辑（Service）
2.数据持久层：CRUD （Dao - 数据持久化对象）

View：
1.展示数据
2.提供链接发起Servlet请求 （a，form，img…）

Controller （Servlet）：
1.接收用户的请求 ：（req：请求参数、Session信息….）

2.交给业务层处理对应的代码

3.控制视图的跳转

登录—>接收用户的登录请求—>处理用户的请求（获取用户登录的参数，username，password）---->交给业务层处理登录业务（判断用户名密码是否正确：事务）—>Dao层查询用户名和密码是否正确–>数据库->返回

13.文件下载

1.文件下载的一般步骤

1.下载文件
2.获取要下载文件的路径
3.获取下载的文件名
4.设置浏览器能够支持下载我们需要的东西
5.获取下载文件的输入流
6.创建缓冲区
7.获取OutputStream对象
8.将FileOutputStream流写入到bufer缓冲区
9.使用OutputStream将缓冲区中的数据输出到客户端

2，实现文件下载功能

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取要下载文件的路径(可以是绝对路径也可以是项目的相对路径)
        String realPath = "D:\\我的图片\\思思\\思思\\beauty_20200706182348.jpg";
        //获取下载的文件名
        String fileName = realPath.substring(realPath.lastIndexOf("\\")+1);
        //设置让浏览器能够支持下载我们需要的东西（固定格式）
        resp.setHeader("Content-Disposition","attachment;filename="+ URLEncoder.encode(fileName,"UTF-8"));
        //获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
        //创建缓冲区
        byte[] buffer = new byte[1024];
        //获取OutputStream对象
       ServletOutputStream out = resp.getOutputStream();
        //用FileInputStream流写入到buffer缓冲区并使用OutputStream将缓冲区中的数据输出到客户端！
        int len = 0;
        while((len = in.read(buffer)) !=-1){
            out.write(buffer,0,len);
        }
        in.close();
        out.close();

    }

14.文件上传

1.上传步骤

处理上传文件需要使用req.getInputStream(),原生方法，使用比较麻烦
建议使用Apache的文件上传组件common-fileupload，它依赖于common-io组件
1.导入common-fileupload和common-io两个jar包
对应的maven依赖

 <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.8.0</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>

2.判断上传的文件是普通表单还是带文件表单,普通表单不处理
直接返回

3.获取上传文件保存路径，上传路径建议放到WEB-INF里面用户无法直接访问，安全

4.处理缓存问题
零时文件如果缓存文件超过了预定大小，我们需要把文件放到一个零时文件中，过几天自动删除，或者提醒用户将文件转存为永久。

5.创建磁盘工厂对象DiskFileItemFactory,处理上传的路径和文件大小限制

DiskFileItemFactory factory = new DiskFileItemFactory();

6.通过磁盘工厂对象获取文件上传对象ServletFileUpload

ServletFileUpload upload = new ServletFileUpload(factory);

7.处理上传文件
ServletFileUpload对象负责将每个表单选项封装成一个个FileItem对象，一般会对它进行遍历，判断他是文件还是其他的东西，再分别处理

List<FileItem> fileItems = upload.parseRequest(request);

注意：一般使用UUID类，生成一个唯一的识别标码，作为上传的文件名进行保存

2.使用实例代码

javaweb文件上传实例代码

3.扩展内容

/*
* 网络传输的东西都需要序列化
* pojo，实体类，如果想要在多台电脑上运行，都需要序列化
* interface Serializable :标记接口，标记意义:序列化
* JVM–>调用本地方法栈（native，是使用C++编写的方法），native–>C++
* */

15.后台实现登录验证码

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setHeader("refresh","3");//设置浏览器每3秒刷新一次
        //告诉浏览器，这个请求用图片的方式打开
        resp.setContentType("image/jpg");
        //网站存在缓存，不让浏览器缓存
        resp.setDateHeader("Expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");
        //把图片写给浏览器
        ImageIO.write(makeImage(),"jpg", resp.getOutputStream());
    }
    //生成随机数
    private String makeNum(){
        Random rd = new Random();
        String num = rd.nextInt(9999999)+"";
        StringBuffer sb = new StringBuffer();
        //确保随机数为7位，不够7位时在前面补零
        for (int i = 0; i <7- num.length(); i++) {
            sb.append("0");
        }
        num = sb +num;
        return num;
    }
    //创建一个图片
    private BufferedImage makeImage(){
        //创建图片对象
        BufferedImage image = new BufferedImage(80, 20,BufferedImage.TYPE_INT_RGB);
        //得到该图片的画笔对象
        Graphics2D pen = (Graphics2D) image.getGraphics();
        //设置图片的背景颜色
        pen.setColor(Color.BLACK);
        pen.fillRect(0,0, 20, 80);//fillRect 填充一个矩形
        //给图片写数据
        pen.setColor(Color.BLUE);
        pen.setFont(new Font(null,Font.BOLD,20));
        pen.drawString(makeNum(),0,20);
        return image;
    }

16.邮件发送

1.步骤

1.导入activation和mail两个jar包，
注意：使用javaweb进行邮件发送时，Tomcat的lib目录也需要导入这两个包
对应的maven依赖

        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>1.4.7</version>
        </dependency>

        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>

2.设置邮箱使用协议

        Properties prop = new Properties();
        prop.setProperty("mail.host","smtp.qq.com");//设置邮箱服务
        prop.setProperty("mail.transport.protocol","smtp");//邮件发送协议
        prop.setProperty("mail.smtp.auth","ture");//需验证用户名密码
        //关于QQ邮箱还需设置SSL加密，加上以下代码即可（QQ才有）
        MailSSLSocketFactory sf = new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.smtp.ssl.enable","true");
        prop.put("mail.smtp.socketFactory",sf);

3.创建整个应用程序需要的环境信息的Session对象

        Session session = Session.getDefaultInstance(prop, new Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                //设置发件人邮箱账户和密码 //QQ才用授权码
                return new PasswordAuthentication("1617511878@qq.com","授权码");
            }
        });

4.通过session得到transport对象

Transport ts = session.getTransport();

5.使用邮箱的用户名和密码/授权码连接上邮箱服务器(发送端)

ts.connect("smtp.qq.com","1617511878@qq.com","授权码");

6.创建邮件
简单邮件：（只含文本）

MimeMessage msg = new MimeMessage(session);
//指明发件人
        msg.setFrom(new InternetAddress("1617511878@qq.com"));
        //指明邮箱的收件人（可以放收件人数组）
        msg.setRecipient(MimeMessage.RecipientType.TO,new InternetAddress("对方的QQ邮箱"));
        //设置邮件的标题
        msg.setSubject("来自李江江的问候");

        //设置邮件的文本内容(纯文本文件只需要下面一行代码)
        msg.setContent("haha","text/html;charset=UTF-8");

复杂邮件：（带附件或者图片）

 MimeMessage msg = new MimeMessage(session);
        //指明发件人
        msg.setFrom(new InternetAddress("1617511878@qq.com"));
        //指明邮箱的收件人（可以放收件人数组）
        msg.setRecipient(MimeMessage.RecipientType.TO,new InternetAddress("1617511878@qq.com"));
//=========================================内容区别线=======================
        //设置邮件的标题
        msg.setSubject("带图片和附件的邮件");

        //准备图片数据
        MimeBodyPart image = new MimeBodyPart();
        //图片需要数据处理 DataHandler：数据处理
        DataHandler dh = new DataHandler(new FileDataSource("src/main/java/source/niu.jpg"));//文件路径
        image.setDataHandler(dh);//添加处理后的数据
        image.setContentID("niu.jpg");//给图片设置一个ID，可以在后面内容中引用

        //准备附件
        MimeBodyPart other1 = new MimeBodyPart();
        //附件需要数据处理
        DataHandler dh1 = new DataHandler(new FileDataSource("src/main/java/source/yingyu.mp3"));
        other1.setDataHandler(dh1);
        other1.setFileName("English.mp3");//中文可能会乱码

        //准备邮件的正文内容
        MimeBodyPart text = new MimeBodyPart();
        //cid:ContentID
        text.setContent("这是带有这个<img src='cid:niu.jpg'>图片和一些附件的邮件","text/html;charset=UTF-8");

        //将文本和图片包装起来
        MimeMultipart mix = new MimeMultipart();
        mix.addBodyPart(text);
        mix.addBodyPart(image);
        //SubType:alternative<related <mixed
              /*
        * alternative：只含有文本
        *related：含有文本和图片
        * mixed：带有文本，图片和附件
        *   */
        mix.setSubType("related");

        //将文本和图片设置为主题
        MimeBodyPart a = new MimeBodyPart();
        a.setContent(mix);

        //将附件拼接得到最终的邮件
        MimeMultipart target = new MimeMultipart();
        target.addBodyPart(other1);
        target.addBodyPart(a);
        target.setSubType("mixed");

        msg.setContent(target);//把编辑好的邮件放到消息中
        msg.saveChanges();

7.发送邮件

//可以同时发送多条
ts.sendMessage(msg,msg.getAllRecipients());
//发送完成，关闭发送流
ts.close();

2.完整的邮件发送案例

java邮件发送完整代码和使用javaweb邮件发送完整案例