文件上传
一般情况下，我们如果要在表单中上传文件，一般会将form的enctype参数设置为multipart/form-data。通常文件上传使用POST请求方式。
原始方法
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
<%--
1.文件上传,表单必须是post提交
2.文件上传,还需要在表单上加上enctype属性(提交请求正文的类型)
application/x-www-form-urlencoded(默认取值,普通提交)
multipart/form-data(多段式提交)
3. 文件上传,使用<input type="file" name="photo" /> 标签,并且必须有name属性
--%>
<form action="/fileupload/Aservlet" method="post" enctype="multipart/form-data">
用户名:<input type="text" name="name" /><br>
个人近照:<input type="file" name="photo" /><br>
<input type="submit" value="上传" />
</form>
</body>
</html>
Aservlet
package fileupload;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/Aservlet")
public class Aservlet extends HttpServlet {
// 文件上传只能用POST提交，实现这个方法就好了
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//1.获得浏览器提交上来的全部信息
InputStream is = request.getInputStream();
//2.提取流中的内容,再根据分隔符
OutputStream os = System.out;
byte[] bytes = new byte[1024];
int len = -1;
while((len=is.read(bytes))!=-1){
os.write(bytes, 0, len);
os.flush();
//3.手动从请求头中获得分割线是什么
//4.使用分隔线分隔请求正文
//5. 从分隔的每一段中 提取信息.
}
}
}
使用工具类方便上传
上面的方法复杂，使用第三方库可以很方便的完成文件上传。提交表达转到Bservlet
package fileupload;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.IOUtils;
@WebServlet("/Bservlet")
public class Bservlet extends HttpServlet {
// 需要用到commons-fileupload.jar, commons-io.jar
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 1. 创建配置工厂
DiskFileItemFactory factory = new DiskFileItemFactory();
// 2. 根据配置工厂创建解析请求中文件上传内容的解析器
ServletFileUpload upload = new ServletFileUpload(factory);
// 3. 判断当前请求是不是多段提交
if (!upload.isMultipartContent(request)) {
throw new RuntimeException("不是多段提交！");
}
try {
// 4. 解析request对象，将已经分割过的内容放进了List
List<FileItem> list = upload.parseRequest(request);
if (list != null) {
for (FileItem fileItem : list) {
// 判断当前段是普通字段还是文件,这个方法是判断普通段
if (fileItem.isFormField()) {
// 获得jsp里name属性对应的值,这里是username
String fname = fileItem.getFieldName();
// 获得用户输入的用户名
String value = fileItem.getString();
System.out.println(fname + "=>"+value );
// 否则就是文件了
} else {
// 获得上传文件的文件名
String name = fileItem.getName();
// 获得文件上传段中，文件的流
InputStream in = fileItem.getInputStream();
// 字节输出流，用以保存文件
FileOutputStream fos = new FileOutputStream("C:\\Users\\"+name);
// 将输入流复制到输出流中
IOUtils.copy(in, fos);
fos.close();
}
}
}
} catch (FileUploadException e) {
e.printStackTrace();
}
}
}
详解DiskFileItemFactory
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 1 创建配置工厂=> 有参的构造可以 直接设置下面两个配置new DiskFileItemFactory(new File("d:/temp"), 10240);
DiskFileItemFactory factory = new DiskFileItemFactory();
// 1.1 设置文件上传临时目录 => 默认位置 => tomcat/temp
factory.setRepository(new File("d:/temp"));
// 1.2 设置文件写入硬盘的缓冲区大小=>默认值=>10k
factory.setSizeThreshold(10240);
}
详解ServletFileUpload
//2 根据配置工厂创建解析器(解析request对象)
ServletFileUpload upload = new ServletFileUpload(factory);
//2.1 判断当前请求是否是多段式提交
upload.isMultipartContent(request);
//2.2 设置多段中每段 段头 在解析时,使用什么码表解码 => 当段头中出现中文时,一定要调用该方式指定段头码表。Content-Disposition: form-data; name="username"
// 这种就是段头
upload.setHeaderEncoding("UTF-8");
//2.3 设置文件最大上传大小 (单位:字节)
upload.setSizeMax(1024*1024*10); // 单次请求,总上传大小限制 10兆.因为是多段式提交，所以可以一次上传多个文件。对单个文件的限制可以使用下面的方法
upload.setFileSizeMax(1024*1024);// 每个文件上传段,大小限制 1兆
FileItem表示分割后的每一段的内容，主要方法如下
boolean isFormField()。// isFormField方法用来判断FileItem对象里面封装的数据是一个普通文本表单字段，还是一个文件表单字段。如果是普通文本表单字段，返回一个true否则返回一个false。因此可以用该方法判断是否是普通表单域还是文件上传表单域。
// 注意下面这两个方法的区别
String getName（）// getName方法用来获得文件上传字段中的文件名。
String getFieldName（）// getFieldName方法用来返回表单标签的name属性的值
String getString（"utf-8"） // 空参或者传入编码方式如"UTF-8"。将FileItem对象中保存的数据流内容以一个字符串返回。如果是普通表单字段，如登录时候输入用户名。则返回用户输入的字段。如果是文件上传则返回文件的内容。
boolean isInMemory() // 判断FileItem对象封装的数据是保存在内存中还是硬盘中。
void write(File file) // write方法将FileItem对象中的内容保存到某个指定的文件中。如果FileItem对象中的内容是保存在某个临时文件中，该方法完成后，临时文件可以会被删除。该方法也可以将普通表单字段保存在一个文件中，但最主要的用途是把上传的文件内容保存在本地文件系统中。
// 上例中也可以直接用fileItem.write(File file)来讲数据写到本地文件
String getContentType() // 此方法用来获得上传文件的类型，即标段字段元素描述头属性“content-type”的值，如image/jpeg。如果FileItem对象对应的是普通的表单字段，将返回null。
InputStream getInputStream() // 以流的形式返回上传文件的主体内容。
OutputStream getOutputStream() // 可以用此方法将输入流写到FileItem中
void delete（） // 此方法用来清空FileItem对象中封装的主体内容，如果内容是被保存在临时文件中，该方法会把临时文件删除。
long getSize() // 返回上传文件的大小。
List<FileItem> list = null;
try {
// 2.4 解析request,将每个分段中的内容封装到FileItem中
list = upload.parseRequest(request);
} catch (FileUploadException e) {
e.printStackTrace();
}
if (list != null) {
for (FileItem item : list) {
// 3.1 item 判断当前分段是否是普通表单段
boolean flag = item.isFormField();
// 3.2获得 表单提交的键.(input元素,name属性的值)
// 普通段和文件上传段都有
String fname = item.getFieldName();
// 3.3 返回文件名称，普通段返回null
String name = item.getName();
// 3.4 获得文件上传中的正文，如果是普通段，如用户登录则是用户自己输入的值。若是文件，则是文件内容。以字符串形式返回段体中的内容 注意:文件上传段不建议使用该方法.使用item.getInputStream()更好
String content = item.getString();
System.out.println("是否是普通表单提交:" + flag + ",表单提交的键:" + fname + ",文件名称:" + name + ",文件内容:" + content);
}
}
解决乱码
文件上传时候的文件名包含中文
ServletFileUpload的setHeaderEncoding("UTF-8");设置一下即可。
段体内容乱码
即getString()返回的内容乱码。fileItem.getString("UTF-8");即可。
上传文件后应该把文件保存到什么位置?
1. 上传后如果需要其他用户可以直接访问,就放到webRoot下.
2. 上传后其他用户不能直接访问, 不直接放在webRoot下。比如WEB-INF下或硬盘其他位置例如 D:\db\xxx.xxx
保存用户上传的文件时的注意事项
使用用户上传的文件名来保存文件的话，文件名可能重复。所以保存文件之前，要保证文件名不会重复。
- 可以使用UUID生成随机字符串
- 可以使用登录用户名+当前系统毫秒数
在一个目录下放所有用户上传的文件显然不明智。可以用如下方法
-
/upload/2017/04/15/xxxx使用当前日期作为子文件夹名称 - 当前登录用户的用户名作为文件夹名称
package fileupload;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.IOUtils;
@WebServlet("/Dservlet")
public class Dservlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 1. 创建配置工厂
DiskFileItemFactory factory = new DiskFileItemFactory();
// 2. 根据配置工厂创建解析请求中文件上传内容的解析器
ServletFileUpload upload = new ServletFileUpload(factory);
// 3. 判断当前请求是不是多段提交
if (!upload.isMultipartContent(request)) {
throw new RuntimeException("不是多段提交！");
}
try {
// 4. 解析request对象，将已经分割过的内容放进了List
List<FileItem> list = upload.parseRequest(request);
if (list != null) {
for (FileItem fileItem : list) {
// 判断当前段是普通字段还是文件,这个方法是判断普通段
if (fileItem.isFormField()) {
// 获得jsp里name属性对应的值,这里是username
String fname = fileItem.getFieldName();
// 获得用户输入的用户名
String value = fileItem.getString("utf-8");
System.out.println(fname + "=>"+value );
// 否则就是文件了
} else {
// 获得文件上传段中，文件的流
InputStream in = fileItem.getInputStream();
// 使用用户上传的文件名来保存文件的话，文件名可能重复。
// 所以保存文件之前，要保证文件名不会重复。使用UUID生成随机字符串
String fileName = UUID.randomUUID().toString();
// 格式化日期
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("/yyyy/MM/dd/");
String datePath = simpleDateFormat.format(new Date()); // 解析成 /2017/04/15/ 的样子, 注意这是三个文件夹
String wholePath = "D:/upload"+datePath;
// 字节输出流，用以保存文件，也不需要后缀名，因为我们只是保存用户的数据，不需要查看他们的数据。待用户想下载的时候，再加上后缀名
File dir = new File(wholePath);
// 判断文件夹是否已经存在，不存在就新建
if (!dir.exists()) {
dir.mkdirs();
}
FileOutputStream fos = new FileOutputStream(wholePath+fileName);
// 将输入流复制到输出流中
IOUtils.copy(in, fos);
fos.close();
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
mkdir()和mkdirs()的区别
mkdirs()可以建立多级目录。即使所有层级的目录都不存在。这些文件夹都会创建。比如我们事先并没有在D盘创建upload和2017等这些文件夹。-
kdir只能用于父级目录已经存在的情况下使用，在已存在的父级目录下再新建一级。只能一级！比如File("D:\upload\2017\04")。且D:\upload\2017是已经存在的。父级 目录存且只新建一级。故
file.makedir()返回true成功创建。但是File("D:\upload\2017\04\15")且D:\upload\2017存在，但不存在15文件夹。所以这里是想新建两级目录。因为父级目录不存在所以创建失败返回false。
多文件同时上传
同时上传多个文件，无非是多写几个<input type="file" name="photo">这样的标签，提交的时候一并上传，同时上传的文件不过是被分成了几段而已。由于List<FileItem> list = upload.parseRequest(request);返回的是全部的FileItem的，所以后台处理的代码不用变。这里用js来处理添加和删除的逻辑。
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort()
+ path + "/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
<script type="text/javascript">
function fun1() {
//1 创建出想要添加的行
var tr = document.createElement("tr");
// this表示当前标签，这里是button
tr.innerHTML = "<td><input type='file' name='photo' /></td><td><input type='button' value='删除' onclick='fun2(this)' /></td>";
//2 找到表格
var table = document.getElementById("one");
//3 找到表格最后一行
var lastRow = table.rows[table.rows.length-1];
//4 insertBefore,由于浏览器解析table的原因。tr的父节点可能并不是table，所以下面的写法兼容了两种情况
lastRow.parentNode.insertBefore(tr, lastRow);
}
//参数: 要删除行中的删除按钮对象，button的父节点是td，td父节点是tr，tr的父节点不一定是table。不过没关系，用tr的父节点去删除tr就行（obj.parentNode.parentNode）
function fun2(obj){
obj.parentNode.parentNode.parentNode.removeChild(obj.parentNode.parentNode);
}
</script>
<form action="/fileupload/Dservlet" method="post" encType="multipart/form-data">
<table border="1" id="one">
<tr>
<th colspan="2">照片上传</th>
</tr>
<tr>
<td><input type="file" name="photo" /></td>
<td><input type="button" value="添加"
onclick="fun1()" /></td>
</tr>
<tr>
<td colspan="2" align="center"><input
type="submit" value="上传" /></td>
</tr>
</table>
</form>
</body>
</html>
文件下载
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<%-- get提交，?name="name" 表示参数--%>
<body>
<a href="/filedownload/Aservlet?name=西电.zip">西电.zip</a> <br>
<a href="/filedownload/Aservlet?name=课.png">课.png</a> <br>
<a href="/filedownload/Aservlet?name=Android基础（四）.md">Android基础（四）.md</a> <br>
</body>
</html>
package filedownload;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;
import javax.print.URIException;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.IOUtils;
@WebServlet("/Aservlet")
public class Aservlet extends HttpServlet {
// 点击超链接属于GET提交
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 原则: 凡是响应正文中需要输出内容, 一定要设置content-type头
String fileName = request.getParameter("name");
System.out.println(fileName);
ServletContext sc = getServletContext();
// 只会截取文件后缀名
String type = sc.getMimeType(fileName);
response.setContentType(type);
// 设置这里让浏览器知道我们下载的文件名，要不默认使用Aservlet这个名称，且没有后缀名.注意这里加了attachment;filename=
// 文件名可能是中文的，下载时候可能出现乱码。要转码成UTF-8
response.setHeader("Content-Disposition", "attachment;filename="+URLEncoder.encode(fileName, "UTF-8"));
// 获得资源输入流
InputStream inputStream = sc.getResourceAsStream("/WEB-INF/resource/"+fileName);
OutputStream outputStream = response.getOutputStream();
IOUtils.copy(inputStream, outputStream);
}
}
注解
什么是注解？它有什么作用?
注解就是 @xxx 这种就是注解.
- 注释:给程序员看的.
- 注解:给程序看。
使用注解的目的: 其实将来使用注解目的就是为了代替传统配置文件。
比如下面三个注解
public class Demo1 implements Person {
@Override
//向编译器描述,该方法是被重写的.
//帮你检查,被注解修饰方法是否是被重写的,如果不是编译报错!
public void eat() {
}
@Deprecated
//该注解告诉编译器,被修饰的方法是过时方法
public static void show(){
System.out.println("hello world!");
}
}
// ***** 另外一个文件 *****
package annotation;
import java.util.ArrayList;
import java.util.List;
public class Test {
// 告诉编译器,不要检查什么错误。
@SuppressWarnings({ "null", "rawtypes", "unchecked" })
// @SuppressWarnings("all") 全部警告都不检查
public static void main(String[] args) {
String str = null;
str.substring(0);
// @SuppressWarnings("unused")
String str2 = null;
// @SuppressWarnings("rawtypes")
List list = new ArrayList();
list.add("abc");
}
}
自定义注解
package annoation;
public @interface MyAnnotation {
}
上面的内容被编译成.class再反编译过来就是这样
interface MyAnnotation extends Annotation
{
}
注解本质上就是一个接口。它扩展了java.lang.annotation.Annotation接口;在java中所有注解都是Annotation接口的子接口。
package annoation;
public @interface MyAnnotation {
//声明属性=> 用抽象方法
//声明一个名为name的属性 类型是String
String name();
}
自定义注解的使用
package annoation;
public class Demo {
// 注意一定要键name
@MyAnnotation(name = "hello")
public void test() {
}
}
注解支持的类型
常见的比如
- 八大基本数据类型
- String
- Array
- Enum枚举
package annoation;
import java.lang.annotation.ElementType;
public @interface MyAnnotation {
//可以使用default关键字,添加属性的默认值。就不用写 a= 了
byte a() default 10;
short b();
int c();
long d();
float e();
double f();
char g();
boolean h();
String i();
String[] j();
ElementType k();
}
package annoation;
import java.lang.annotation.ElementType;
public class Demo {
@MyAnnotation(
b = 1000,
c = 10000,
d = 100000,
e = 3.14f,
f = 3.1415926,
g = 'a',
h = true,
i = "tom",
j = "jack",
k = ElementType.FIELD)
//数组属性在赋值时使用大括号. => j = { "jack","rose" }
//如果数组中只有一个元素.那么可以忽略大括号 j = "jack"
public void test() {
}
}
注意
如果注解中,必填属性只有一个. 这个属性的名字是"value".那么在赋值时不需要加属性的键.
package annoation;
import java.lang.annotation.ElementType;
public @interface MyAnnotation {
String value();
// 或者String[] value();
}
package annoation;
public class Demo {
// 没加value="good",直接下面这样就行
@MyAnnotation("good")
public void test() {
}
}
可以使用default关键字,添加属性的默认值。就不用写 a=了
int a() default 10;
元注解
package annoation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//元注解 (4个)
//修饰注解的注解
//RetentionPolicy.SOURCE 注解会保留到Java源文件这一阶段 ，编译成class文件后就不存在了
//RetentionPolicy.CLASS 注解在源文件和编译成class文件后也还存在
//RetentionPolicy.RUNTIME 注解在源文件、编译后的class文件、以及运行时期都存在
//
@Retention(RetentionPolicy.RUNTIME)
//@Target 注解支持加在什么位置
//ElementType.CONSTRUCTOR 构造方法
//ElementType.METHOD 方法
// 比如下面，注解可以加、在构造函数，方法和类上
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE})
//@Inherited 所加的注解可否被继承
@Inherited
//@Documented 生成java文档时候也保留注解
@Documented
public @interface MyAnnotation2 {
}
注解小例子
package annoation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation3 {
double value();
}
模拟银行转账，注解的作用是：单笔转账不得超过1000
package annoation;
import java.lang.reflect.Method;
public class BankTransfer {
@MyAnnotation3(10000)
public static void trans(String person, String another, double money) throws ClassNotFoundException, NoSuchMethodException {
// Method m = BankService.class.getMethod("zz",String.class,String.class,double.class);
// 也可以上面的写法
// 1. 获得注解所在的反射对象
Method m = Class.forName("annoation.BankTransfer").getMethod("trans", String.class, String.class, double.class);
//2 判断方法是否被注解修饰
if (m.isAnnotationPresent(MyAnnotation3.class)) {
//3 获得注解的属性值
MyAnnotation3 myAnnotation = m.getAnnotation(MyAnnotation3.class);
double maxmoney = myAnnotation.value();
if (money > maxmoney) {
throw new RuntimeException("单次转账不能超过" + maxmoney + "元!");
}
System.out.println(person + "给" + another + "转了" + money + "元!");
} else {
//没被注解修饰
throw new RuntimeException("系统异常,不能转账!");
}
}
public static void main(String[] args) throws NoSuchMethodException, ClassNotFoundException {
trans("我", "你", 100000);
}
}
重写JDBCUtils
代替配置文件，使用注解
package annoation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
// 加到类上
@Target(ElementType.TYPE)
public @interface JDBCInfo {
String className();
String url();
String user();
String password();
}
package annoation;
import java.sql.*;
@JDBCInfo(className = "com.mysql.jdbc.Driver", url = "jdbc:mysql://localhost:3306/example", user = "root", password ="admin")
public class JDBCUtils {
private static String driver;
private static String url;
private static String user;
private static String password;
// 静态代码块，随着类的加载而加载，只加载一次
static {
try {
//获得注解中配置的属性
//1 获得注解所在的反射对象
//2 获得注解的实现类
JDBCInfo info = Class.forName("annoation.JDBCUtils").getAnnotation(JDBCInfo.class);
//3 获得4个属性值
driver = info.className();
url=info.url();
user=info.user();
password=info.password();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static Connection getConnection() {
Connection connection = null;
try {
connection = DriverManager.getConnection(url, user, password);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("创建连接失败！");
}
return connection;
}
// 释放资源
// 参数可能为空
// 调用close要抛出异常，即使出现异常也能关闭
public void close(Connection conn, Statement state, ResultSet result) {
try {
if (result != null) {
result.close();
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
if (state != null) {
state.close();
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
System.out.println(getConnection());
}
}
以前写的使用properties来保存并读取配置文件。对比一下
package jdbc;
import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JDBCUtil {
private static String driver;
private static String url;
private static String user;
private static String password;
// 静态代码块，随着类的加载而加载，只加载一次
static {
try {
Properties prop = new Properties();
// load()接收InputStream，所以向上转型
InputStream is = new FileInputStream("src/jdbc/jdbc_setting.properties");
prop.load(is);
driver = prop.getProperty("ClassName");
url = prop.getProperty("url");
user = prop.getProperty("user");
password = prop.getProperty("password");
Class.forName(driver);
is.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnection() {
Connection connection = null;
try {
connection = DriverManager.getConnection(url, user, password);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("创建连接失败！");
}
return connection;
}
// 释放资源
// 参数可能为空
// 调用close要抛出异常，即使出现异常也能关闭
public static void close(Connection conn, Statement state, ResultSet result) {
if (result != null) {
try {
result.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (state != null) {
try {
state.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
}
}
public static void main(String[] args) {
System.out.println(getConnection());
}
}
枚举简介
通常描述数量固定的属性。比如性别，一周从周一到周日，这些都是固定的 。为了定义这些量，我们可以这样写。
public class Sex {
// 静态代码块最先执行，所以这里定义的时候不初始化也不会报错
public static final Sex MALE;
public static final Sex FEMALE;
static {
MALE = new Sex();
FEMALE = new Sex();
}
// 或者不用静态代码块的方法，直接下面这样
// public static final Sex MALE = new Sex();
// public static final Sex FEMALE = new Sex();
public static void main(String[] args) {
//男性
Sex male = Sex.MALE;
//女性
Sex female = Sex.FEMALE;
}
}
如果使用枚举就很省事
package annoation;
public enum Sex2 {
MALE, FEMALE;
}
测试一下
public static void main(String[] args) {
//男性
Sex2 male = Sex2.MALE;
//女性
Sex2 female = Sex2.FEMALE;
}
by @sunhaiyu
2017.4.15
