Web的基本概念
静态web
html，css 提供给所有人看的数据始终不会变化
动态web
提供给所有人看，会发生变化的，每个人在不同的时间，不同的地点看到的信息是不同的；例如淘宝；技术栈包括servlet、jsp、asp、php
优点：
web页面可以动态更新，所有用户看到都不是同一个页面
可以与数据库交互（数据持久化）
web服务器讲解
php
php开发速度很快，功能很强大，跨平台，代码简单
无法承载大访问量的情况（局限性）
JSP、Servlet
sun公司主推的BS架构，基于java语言开发，可以承载三高问题带来的影响
BS架构
浏览器和服务器
CS架构
客户端和服务器
web服务器
服务器是一种被动的操作，用来处理用户的一些请求和给用户一些响应信息
Tomcat
免费开源的一款轻量级应用服务器，在小型系统和并发用户不多的场合下使用度高，可以运行JSP页面和Servlet
Http详解
HTTP（超文本传输协议）是一个简单的请求-响应协议，它通常运行在TCP之上
文本：html、字符串。。。
超文本：图片、音乐、定位、视频、地图。。。
Http请求
客户端—发请求（Request）—服务器
Request URL:https://www.baidu.com/ 请求地址
Request Method:GET get方法、post方法
Status Code:200 OK 状态码200
Remote Address:14.215.177.39:443 远程地址
请求行
请求行中的请求方式：GET
请求方式：Get、Post。。。
get请求
请求能够携带的参数较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但是高效
post请求
请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但是不高效
消息头
Accept：告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式 GBK UTF-8 GB2312
Accept-Language：告诉浏览器，语言环境
Cache-Control：缓存控制
Connection：告诉浏览器，请求完成是断开还是保持连接
Http响应
服务器—响应----客户端
Cache-Control:private 缓存控制
Connection:keep-alive 连接
Content-Encoding:gzip 编码
Content-Type:text/html;charset=utf-8 类型
响应体
Accept：告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式 GBK UTF-8 GB2312
Accept-Language：告诉浏览器，语言环境
Cache-Control：缓存控制
Connection：告诉浏览器，请求完成是断开还是保持连接
Host：主机
refrush：告诉客户端，多久刷新一次
Location：让网页重新定位
响应状态码
200：请求响应成功
3**：请求重定向，重新到另一个指定的路径
4**：找不到资源
5**：服务器代码错误
HelloWorld
pom依赖
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artfactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artfactId>
<version>2.3.3</version>
</dependency>
hello示例代码
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 响应的类型：html
resp.setContentType("text/html");
// 获取响应的输出流
PrintWriter writer = resp.getWriter();
writer.println("<html>");
writer.println("<head>");
writer.println("<title>hello hupf</title>");
writer.println("</head>");
writer.println("<body>");
writer.println("<h1>hello hupf</h1>");
writer.println("</body>");
writer.println("</html>");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<!--web.xml中是配置我们web的核心应用-->
<!--注册Servlet-->
<servlet>
<servlet-name>helloServlet</servlet-name>
<servlet-class>com.hupf.servlet.HelloServlet</servlet-class>
</servlet>
<!--一个servlet对应一个mapping：映射-->
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<!--请求路径-->
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>
对于servlet接口，sun公司有两个默认的实现类：
1.HttpServlet
2.GenericServlet
为什么需要映射：我们写的是JAVA程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务器中注册我们写的Servlet，还需给他一个浏览器能够访问的路径
Servlet原理
Servlet是由web服务器调用，web服务器在收到浏览器请求之后，会调用servlet，调用service方法，将响应返回给servlet、客户端
Mapping
- 一个servlet可以指定一个映射路径
<servlet>
<servlet-name>helloServlet</servlet-name>
<servlet-class>com.hupf.servlet.HelloServlet</servlet-class>
</servlet>
<!--一个servlet对应一个mapping：映射-->
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
- 一个servlet可以指定多个映射路径
<servlet>
<servlet-name>helloServlet</servlet-name>
<servlet-class>com.hupf.servlet.HelloServlet</servlet-class>
</servlet>
<!--一个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可以指定通用映射路径
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>/hello/*</url-pattern>
</servlet-mapping>
- 默认请求路径
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
- 指定一些后缀或前缀等等
<!--*号前不能加项目映射的路径-->
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
- 优先级问题
指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求
<!--404-->
<servlet>
<servlet-name>error</servlet-name>
<servlet-class>com.kuang.servlet.ErroeServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>error</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
ServletContext对象
全局参数配置和servlet初始化参数配置：
<!--全局初始化参数-->
<context-param>
<param-name></param-name>
<param-value><param-value>
</context-param>
<servlet>
<servlet-name>error</servlet-name>
<servlet-class>com.kuang.servlet.ErroeServlet</servlet-class>
<!--配置初始化参数-->
<init-param>
<param-name></param-name>
<param-value></param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>error</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
ServletContect对象
web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContect对象，他代表了当前的web应用：
-
共享数据
我在这个servlet中保存的数据，可以在另外一个servlet中拿到示例代码：
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取servletcontext对象
ServletContext servletContext = this.getServletContext();
// 设置属性值
servletContext.setAttribute("name","hupf");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
public class Servlet1 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取servletcontext对象
ServletContext servletContext = this.getServletContext();
// 获取属性值
String name = servletContext.getAttribute("name").toString();
resp.getWriter().println(name);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
在web.xml中配置完servlet映射，先访HelloServlet，再访问servlet1，输出：
hupf
- 获取初始化参数
<!--全局初始化参数-->
<context-param>
<param-name>URL</param-name>
<param-value>www.baidu.com<param-value>
</context-param>
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取servletcontext对象
ServletContext servletContext = this.getServletContext();
// 获取属性值
String url = servletContext.getAttribute("URL").toString();
resp.getWriter().println(url);
}
请求转发
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取servletcontext对象
ServletContext servletContext = this.getServletContext();
// 请求转发
servletContext.getRequestDispatcher("/hello").forward(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
转发：客户端请求服务器，服务器说你请求的这个servlet不能解决问题，我的另一个servlet能解决你的问题，我安排他给你解决
重定向：客户端请求服务器，服务器说你的这个请求处理不了，我给你介绍一个servlet，他能解决你的请求，给你地址你去找它
读取资源文件
properties
- 在java目录下新建properties
- 在resource目录下新建properties
发现：都被打包到了同一路径下：classes，我们俗称这个路径是classpath
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
InputStream resourceAsStream = this.getServletContext().
getResourceAsStream("/WEB-INF/classes/db.properties");
Properties properties = new Properties();
properties.load(resourceAsStream);
properties.getProperty("username");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
HttpServletResponse
web服务器接收到客户端的http请求，针对这个请求，分别创建
一个代表请求的HttpServletRequest对象
一个代表响应的HttpServletResponse对象
- 如果要获取客户端请求过来的参数：找HttpServletRequest
- 如果要给客户端响应一些信息：找HttpServletResponse
简单分类
负责向浏览器发送数据的方法
servletOutputStream getOutputStream() throws IOExecption;
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);
下载文件
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 要获取下载文件的路径
String realPath = this.getServletContext().getRealPath("1.png");
// 下载文件的文件名
String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
// 设置让浏览器能够支持下载我们需要的东西
resp.setHeader("Content-Disposition","attachment;ilename="+fileName);
// 获取下载文件的输入流
FileInputStream in = new FileInputStream(realPath);
// 创建缓冲区
int len = 0;
byte[] buffer = new byte[1024];
// 获取OutputStream对象
ServletOutputStream out = resp.getOutputStream();
// 将FileOutputStream流写入到buffer缓冲区，使用OutputStream将缓冲区中的数据输出到客户端
while ((len=in.read(buffer))>0){
out.write(buffer,0,len);
}
in.close();
out.close();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
验证码实现
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 如何让浏览器3秒自动刷新一次
resp.setHeader("refresh","3");
// 在内存中创建一个图片
BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
// 获取图片
Graphics g = 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(makeNum(),0,20);
// 告诉浏览器，这个请求用图片的方式打开
resp.setContentType("image/jpeg");
// 网站存在缓存，不让浏览器缓存
resp.setDateHeader("expires",-1);
resp.setHeader("Cache-Control","no-cache");
resp.setHeader("Pragma","no-cache");
// 把图片写到浏览器
boolean write = ImageIO.write(image,"jpg", resp.getOutputStream());
}
// 生成随机数
private String makeNum(){
Random random = new Random();
String num = random.nextInt(9999999)+"";
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 7-num.length(); i++) {
sb.append("0");
}
return sb.toString();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
重定向
web资源B收到客户端A请求后，B它会通知A客户端去访问另外一个web资源C，这个过程叫重定向
常见场景：
用户登录
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重定向
resp.sendRedirect("/AA/img");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
HttpServletRequest
HttpServletRequest代表客户端的请求，用户通过http协议访问服务器，http请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获取客户端的所有信息
1.获取参数
request.getParameter(String s);
request.getParameterMap();
request.getParameterNames();
request.getParameterValues(String s);
2.重定向和转发的区别
相同：
页面都会跳转
不同：
请求转发的时候，url不会生发变化，状态码是307
重定向的时候，url地址栏会发生变化，状态码是302
Cookie、Session讲解
会话
用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话
有状态会话
客户端请求过一次服务器后，下次再请求，服务器就会知道曾经来过，称之为有状态会话
1.服务器给客户端一个信件，客户端下次访问服务端带上信件就可以了，cookie
2.服务器登记客户端访问过，下次来可以匹配session
保存会话的两种技术
cookie：客户端技术（响应，请求）
session：服务器技术，利用这个技术，可以保存用户的会话信息，我们可以把信息或者数据放在session中
常见场景：网站登录后，下次就不需要再登陆了，等二次可以直接登录
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
PrintWriter out = resp.getWriter();
// Cookie 服务器端从客户端获取
Cookie[] cookie = req.getCookie();// 这里返回数组，说明cookie可能存在多个
// 判断Cookie是否存在
if(cookie!=null){
// 如果存在怎么办
out.println("上一次访问时间是：");
for(int i=0;i<cookie.length;i++){
Cookie c = cookie[i];
// 获取cookie的名字
if(c.getName().equals("name")){
// 获取值
long time = Long.parseLong(c.getValue());
Date date = new Date(time);
out.println(date.toLocaleString());
}
}
}else{
out.println("这是第一次访问");
}
// 服务给客户端响应一个cookie
Cookie c = new Cookie("time",System.currentTimeMillis()+"");
resp.addCookie(c);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
Cookie的常用方法
1.从请求中拿到cookie信息
2.服务器响应（新建）给客户端cookie
// 获取cookie
Cookie[] cookie = req.getCookie();
// 获得cookie中的key
cookie.getName();
// 获得cookie中的value
cookie.getValue();
// 新建一个cookie
new Cookie("time",System.currentTimeMillis()+"");
// 设置cookie的有效期
cookie.setMaxAge(24*60*60);
// 响应给客户端一个cookie
resp.addCookie(cookie);
cookie：一般会保存再本地的用户目录下的appdata文件夹中
一个网站cookie是否存在上限呢？
一个cookie只能保存一个信息
一个web站点可以给浏览器发送多个cookie，最多存放20个cookie
300个cookie是浏览器的上限
cookie大小限制4KB
删除cookie的方法
不设置有效期，关闭浏览器，自动失效
设置有效期时间为0
编码解码
URLEncoder.encode("南开大学","utf-8");
URLDecoder.decode(cookie.getValue(),"utf-8");
Seesion(重点)
什么是session：
服务器会给每一个用户（浏览器）创建一个session对象
一个session独占一个浏览器，只要浏览器没有关闭，这个session就存在
用户登录之后，整个网站他都可以访问–>保存用户的信息
Session常用方法
public class SessionDemo01 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 解决乱码问题
resp.setCharacterEncoding("UTF-8");
req.setCharacterEncoding("UTF-8");
resp.setContentType("text/html;charset=utf-8");
// 得到Session
HttpSession session = req.getSession();
// 给Session中存键值对
session.setAttribute("name","hupf");
// 获取Session的ID
String id = session.getId();
// 判断Session是不是新建的
if(session.isNew()){
resp.getWriter().write("session创建成功，ID："+id);
}else{
resp.getWriter().write("session已经在服务器中存在了，ID："+id);
}
// Session创建的时候做了什么
Cookie cookie = new Cookie("JSESSIONID",id);
resp.addCookie(cookie);
// session删除值
session.removeAttribute("name");
// Session注销
session.invalidate();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
session的设置
<!--设置Session默认的失效时间-->
<session-config>
<!--15分钟后Session自动失效，以分钟为单位-->
<session-timeout>15</session-timeout>
</session-config>
一个servlet给session设置值，另一个servlet可以获取这个session中的值
一个浏览器开几个页面，session都是一样的
session和cookie的区别
- Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
- Session把用户的数据写到用户独占的Session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）
- Session对象由服务器端创建
使用场景：
保存一个登录用户的信息
购物车信息
在整个网站中经常会使用的数据，我们将它保存在Session中
JSP原理
什么是JSP
java server pages：java服务器端页面，也和servlet一样，用于动态web技术
最大的特点：
写JSP就像在写HTML
HTML只给客户提供静态的数据，JSP页面中可以嵌入java代码，为用户提供动态数据
JSP原理
思路：JSP到底怎么执行
- 服务器内部工作
tomcat中有一个work目录
IDEA中使用Tomcat，会在IDEA的tomcat中生产一个work目录 - JSP页面在IDEA下的tomcat目录下，转化成了java代码
- 浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet
- JSP最终会被转换成一个java类
- JSP本质上就是一个servlet
- 在JSP页面中，只要是java代码(<%…%>)就会原封不动的输出，html代码会转换为out.write("…")
JSP的基础语法
MVC三层架构
Model，View，Controller
模型，视图，控制器
model
- 业务处理：业务逻辑（service）
- 数据持久层：CRUD（dao）
View
- 展示数据
- 提供连接发起service请求（a,from,img）
Controller
- 接收用户的请求：（req：请求参数，session信息）
- 交给业务层处理对应的代码
- 控制视图层跳转
过滤器（Filter）
public class SessionDemo01 implements Filter {
// 初始化：web服务器启动，就已经初始化了
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
// 过滤器中的所有代码，在过滤指定请求时都会执行
// 多个过滤器可以依次串行执行过滤
@Override
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");
System.out.println("");
// 放行请求，如果不写，请求会被拦截在这里
filterChain.doFilter(servletRequest,servletResponse);
}
// 销毁：web服务器关闭的时候，过滤会销毁
@Override
public void destroy() {
}
}
和servlet一样，需要在web.xml中配置过滤器
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>com.kuang.filter.CharacterEncodingFilter<filter-class>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
监听器（Listener）
实现一个监听器的接口（监听器的接口有很多）
// 统计网站在线人数：统计session
public class OnlineCountListener implements HttpSessionListener {
// 创建session监听，看你的一举一动
// 一旦创建session就会触发一次这个事情
@Override
public void sessionCreated(HttpSessionEvent se){
ServletContext ctx = se.getSession().getServletContext();
Integer onlineCount = (Integer)ctx.getAttribute("OnlineCount");
if (onlineCount == null){
onlineCount = new Integer(1);
}else{
int count = onlineCount.intValue();
onlineCount = new Integer(count+1);
}
ctx.setAttribute("OnlineCount",onlineCount);
}
// 销毁session监听
@Override
public void sessionDestroyed(HttpSessionEvent se){
ServletContext ctx = se.getSession().getServletContext();
Integer onlineCount = (Integer)ctx.getAttribute("OnlineCount");
if (onlineCount == null){
onlineCount = new Integer(0);
}else{
int count = onlineCount.intValue();
onlineCount = new Integer(count-1);
}
ctx.setAttribute("OnlineCount",onlineCount);
}
}
向web.xml中注册监听器
<listener>
<listener-class>com.kuang.listener.OnlineCountListener</listener-class>
</listener>
session销毁的方式
1.自动销毁
<session-config>
<session-timeout>1</session-timeout>
</session-config>
2.手动销毁
session.invalidate();
过滤器实现权限拦截
用户登陆后才能进入主页，用户注销后就不能进入主页
登录页面对应的LoginServlet
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取前端请求的参数
String username = req.getParameter("username");
if(username.equals("admin")){// 登录成功
req.getSession().setAttribute("USER_SESSION",req.getSession().getId());
resp.sendRedirect("/sys/success.jsp");
}else{// 登录失败
resp.sendRedirect("/error.jsp");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
注销方法
public class LoginOutServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
Object user_session = req.getSession().getAttribute("USER_SESSION");
if (user_session!=null){
req.getSession().removeAttribute("USER_SESSION");
}
resp.sendRedirect("Login.jsp");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
系统过滤器
public class SysFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest requset = (HttpServletRequest)req;
HttpServletResponse response = (HttpServletResponse)resp;
if(requset.getSession().getAttribute("USER_SESSION") == null){
response.sendRedirect("/error.jsp");
}
filterChain.doFilter(requset,response);
}
@Override
public void destroy() {
}
}
讲解一个超市订单管理系统（smbms）
数据库管理类
// 操作数据库的公共类
public class BaseDao {
private static String driver;
private static String url;
private static String username;
private static String password;
// 静态代码块，类加载的时候就初始化了
static{
Properties properties = new Properties();
// 通过类加载器读取对应的资源
InputStream is = BaseDao.class.getClassLoader().getResourceAsStream("db.properties");
try {
properties.load(is);
} catch (Exception e){
e.printStackTrace();
}
driver = properties.getProperty("driver");
url = properties.getProperty("url");
username = properties.getProperty("username");
password = properties.getProperty("password");
}
// 获取数据库的连接
public static Connection getConnection(){
Connection connection = null;
try {
Class.forName(driver);
connection = DriverManager.getConnection(url,username,password);
} catch (Exception e){
e.printStackTrace();
}
return connection;
}
// 编写查询公共类
public static ResultSet execute(Connection connection,String sql,Object[] params,ResultSet resultSet,PreparedStatement preparedStatement) throws SQLException {
// 预编译的sql，在后面直接执行就可以了
preparedStatement = connection.prepareStatement(sql);
for (int i=0; i<params.length; i++){
// setObject,占位符从1开始，但是我们的数组是从0开始
preparedStatement.setObject(i+1,params[i]);
}
resultSet = preparedStatement.executeQuery();
return resultSet;
}
// 编写增删改公共类
public static int execute(Connection connection,String sql,Object[] params,PreparedStatement preparedStatement) throws SQLException {
preparedStatement = connection.prepareStatement(sql);
for (int i=0; i<params.length; i++){
// setObject,占位符从1开始，但是我们的数组是从0开始
preparedStatement.setObject(i+1,params[i]);
}
int updateRows = preparedStatement.executeUpdate();
return updateRows;
}
// 释放资源
public static boolean closeResource(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet){
boolean flag = true;
if(resultSet != null){
try{
resultSet.close();
// GC回收
resultSet = null;
}catch (Exception e){
e.printStackTrace();
flag=false;
}
}
if(preparedStatement != null){
try{
preparedStatement.close();
// GC回收
preparedStatement = null;
}catch (Exception e){
e.printStackTrace();
flag=false;
}
}
if(connection != null){
try{
connection.close();
// GC回收
connection = null;
}catch (Exception e){
e.printStackTrace();
flag=false;
}
}
return flag;
}
}
文件传输原理及介绍
文件上传的注意事项：
1.为了保证服务器安全，上传文件应该放在外界无法直接访问的目录下，比如WEB-INF目录下
2.为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名
3.要限制上传文件的最大值
4.可以限制上传文件类型，在收到上传文件名时，判断后缀名是否合法
public class FileServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 判断上传的文件是普通表单还是带文件的表单
if (ServletFileUpload.isMultipartContent(req)){
return;// 终止方法运行，说明是一个普通表单
}
//创建上传文件的保存路径，建议在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 tmpFile = new File(tmpPath);
if(!tmpFile.exists()){
tmpFile.mkdir();// 创建这个临时目录
}
// 处理上传的文件，一般需要通过流来获取，我们可以使用request.getInputStream(),原生态的文件上传流获取，十分麻烦
// 但是我们都建议使用Apache的文件上传组件来实现，common-fileupload，它需要依赖于common-io组件
// 1.创建DiskFileItemFactory对象，处理文件上传路径或者大小限制的
DiskFileItemFactory factory = new DiskFileItemFactory();
// 通过这个工厂设置一个缓冲区，当上传文件大于这个缓冲区的时候，将他放到临时文件中
factory.setSizeThreshold(1024*1024);// 设置缓冲区大小为1M
factory.setRepository(tmpFile);// 临时目录的保存目录，需要一个File
// 2.获取ServletFileUpload
ServletFileUpload upload = new ServletFileUpload(factory);
// 监听文件上传进度
upload.setProgressListener(new ProgressListener() {
@Override
public void update(long pByteRead, long pContentLength, int pItems) {
System.out.println("总大小:"+pContentLength+" 已上传:"+pByteRead);
}
});
// 处理文件乱码问题
upload.setHeaderEncoding("UTF-8");
// 设置单个文件的最大值
upload.setFileSizeMax(1024*1024*10);
// 设置总共能上传的文件大小
upload.setSizeMax(1024*1024*10);
// 3.处理上传文件
try {
// 把前端请求解析，封装成一个FileItem对象
List<FileItem> fileItems = upload.parseRequest(req);
for (FileItem fileItem : fileItems) {
// 判断上传的文件是普通表单还是带文件的表单
if (fileItem.isFormField()){
String name = fileItem.getFieldName();
String value = fileItem.getString("UTF-8");
}else{// 文件
// 处理文件
String uploadFileName = fileItem.getName();
// 可能存在文件名字不合法
if(uploadFileName.trim().equals("")||uploadFileName==null){
continue;
}
// 获得上传文件的名字
String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/" + 1));
// 获得文件的后缀名
String fileExtName = uploadFileName.substring(uploadFileName.lastIndexOf("." + 1));
// 可以使用UUID，保证文件名唯一
// 标记接口：没有声名方法的空接口
// 函数式接口：只有哦一个方法声明的接口
UUID uuid = UUID.randomUUID();
//存放位置
String realpath = uploadPath+"/"+uuid;
File file = new File(realpath);
if(!file.exists()){
file.mkdir();
}
//文件传输
// 获得文件上传的流
InputStream inputStream = fileItem.getInputStream();
FileOutputStream fileOutputStream = new FileOutputStream(realpath+"/"+fileName);
byte[] buffer = new byte[1024 * 1024];
int len = 0;
while((len=inputStream.read(buffer))>0){
fileOutputStream.write(buffer,0,len);
}
fileOutputStream.close();
fileItem.delete();// 上传成功，清除临时文件
}
return;
}
} catch (FileUploadException e) {
e.printStackTrace();
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
发送邮件
// 发送简单的邮件
public class MailTest01 {
public static void main(String[] args) {
Properties properties = new Properties();
properties.setProperty("mail.host","smtp.qq.com");// 设置QQ邮箱服务器
properties.setProperty("mail.transport.protocol","smtp");// 邮件发送协议
properties.setProperty("mail.smtp.auth","true");// 需要验证用户迷宫密码
// 关于QQ邮箱，还要设置SSL加密，加上一下代码即可
MailSSLSocketFactory sf = new MailSSLSocketFactory();
sf.setTrueAllHosts(true);
properties.put("mail.smtp.ssl.enable","true");
properties.put("mail.smtp.ssl.socketFactory",sf);
// 使用JavaMail发送邮件的5个步骤
// 创建定义整个应用程序所需要的环境信息的session对象
Session session = Session.getDefaultInstance(properties,new Authenticator(){
public PasswordAuthentication getPasswordAuthentication(){
// 发件人邮件用户名，授权码
return new PasswordAuthentication("xxxx@qq.com","授权码");
}
});
// 开启session的debug模式，这样就可以查看到程序发送email的运行状态
session.setDebug(true);
// 通过session得到Transport对象
Transport ts = session.getTransport();
// 使用邮箱的用户名和授权码连上邮件服务器
ts.connect("smtp.qq.com","xxxx@qq.com","授权码");
// 创建邮件
// 创建邮件对象
MimeMessage message = new MimeMessage(session);
// 指明邮件的发件人
message.setFrom(new InternetAddress("xxxxx@qq.com"));
// 指明邮件的收件人，现在发件人和收件人是一样的，那就是自己给自己发
message.setRecipient(Message.Recipient.To, new InternetAddress("xxxxx@qq.com"));
// 邮件的标题
message.setSubject("只包含文本的简单邮件");
// 准备图片数据
MineBodyPart image = new MineBodyPart();
DataHandler dh = new DataHandler(new FileDataSource("src/resources/bz.jpg"));
image.setDataHandler(dh);
image.setContent("bz.jpg");
// 准备正文数据
MineBodyPart text = new MineBodyPart();
text.setContent("这是一封邮件正文带图片","text/html;charset=utf-8");
// 描述数据关系
MineMultipart mm = new MineMultipart();
mm.addBodyPart(text);
mm.addBodyPart(image);
mm.setSubType("related");
// 设置到消息中，保存修改
message.setContent(mm);
message.saveChanges();
// 邮件的文本内容
ts.sendMessage(message,message.getAllRecipients());
// 发送邮件
ts.close();
}
}
250
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
