Java on 庞玉栋个人博客

Java两种方法实现简单爬虫

Thu, 28 Nov 2019 16:21:04 +0800

第一种：利用HttpClient和Jsoup爬取网站数据

package com.company;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
public class Main {
public static void main (String[] args) throws Exception {
 // 创建默认的客户端实例
 CloseableHttpClient httpClient = HttpClients.createDefault();

 // 创建get请求实例
 HttpGet httpget = new HttpGet("/");

 System.out.println("executing request " + httpget.getURI());
 String content = "";

 try {
 // 客户端执行get请求返回响应
 CloseableHttpResponse response = httpClient.execute(httpget);

 // 服务器响应状态行
 System.out.println(response.getStatusLine().toString());

 Header[] heads = response.getAllHeaders();
 HttpEntity entity = response.getEntity();

 if (entity != null) {
 content += EntityUtils.toString(entity, "utf-8");
 EntityUtils.consume(entity);// 关闭内容流
 }

 System.out.println(content);
 System.out.println(response.getHeaders("Content-Type"));
 // 打印所有响应头

 for(Header h:heads){
 System.out.println(h.getName()+":"+h.getValue());
 }
 } finally {
 httpClient.close();
 }
}

}

Java实现冒泡排序

Sat, 16 Feb 2019 10:38:10 +0800

冒泡排序：

利用冒泡排序对数组进行排序

基本概念：

依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

代码如下：

package 冒泡排序;
import java.util.Arrays;
public class BubbleSort1 {
public static void BubbleSort(int[] arr) {
boolean flag = true;
while(flag){
int temp;//定义一个临时变量
for(int i=0;i<arr.length-1;i++){//冒泡趟数，n-1趟
for(int j=0;j<arr.length-i-1;j++){
if(arr[j+1]<arr[j]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
flag = true;
}
}
if(!flag){
break;//若果没有发生交换，则退出循环
}
}
}
}
public static void main(String[] args) {
int arr[] = new int[]{1,6,2,2,5};
BubbleSort.BubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
}

如何从命令提示符运行Java程序

Sat, 28 Jul 2018 13:51:21 +0800

Java是最常用的编程语言之一。它也是一个IDE密集型编程语言，与Eclipse紧密集成。如果您刚开始学习Java，下面是帮助您从命令提示符开始运行Java应用程序（在Windows中）的基本指南。

安装Java开发工具包（JDK）

在您的计算机上运行Java程序之前，您需要安装一个Java编译器。它附带了Java开发工具包或JDK。它是Java在任何平台上开发的基本工具。JDK与Java运行时环境(或JRE)不一样，如果您在您的机器上使用过Java应用程序，您已经安装了它。

1．从Oracle的网站上下载JDK。确保不要下载到服务器版本的JRE。

2．确保您获取了开发工具包的Windows版本。

3.正常运行安装程序。

从命令提示符运行Java程序

1.使用记事本或其他文本编辑器创建一个如下所示的简单Java程序。请确保以扩展名“.java”而不是“.txt”保存文件。

2.从开始菜单打开命令提示符。您也可以按Win R，然后在运行字段中输入cmd.exe。

3.使用cd命令将工作目录更改为包含Java程序的目录。我保存在我的“脚本”文件夹中，但是您可以将您的文件保存在系统中的任何位置。

4．在您的计算机上定位到Java开发工具包(JDK)版本的路径。如果你运行64位Windows，那通常是在“C：\ Program Files \ Java”中。

5.使用“set”命令设置JDK的路径，如下所示：

您可能需要更改目录路径以反映当前版本的Java。确保您使用的是Java开发工具包(JDK)目录，并指向“bin”文件夹。Java运行时环境(JRE)文件夹也包含一个“bin”文件夹，但不包含Java编译器。如果在编译过程中出现错误，请确保使用正确的目录路径。

6.使用javac命令编译Java程序，如下所示：

7.你应该看到什么都没有发生。但是，如果您使用dir命令，则会在您的目录中以“.class”扩展名结尾注意到一个新文件。这表示程序已经编译完成。

Kotlin 扩展函数详解与应用

Fri, 23 Feb 2018 11:31:21 +0800

一、什么是扩展函数？

扩展函数数是指在一个类上增加一种新的行为，甚至我们没有这个类代码的访问权限。这是一个在缺少有用函数的类上扩展的方法，Kotlin能够为我们做到那些令人关注的事情，而这些Java做不到。

在Java中，通常会实现很多带有static方法的工具类，而Kotlin中扩展函数的一个优势是我们不需要在调用方法的时候把整个对象当作参数传入，它表现得就像是属于这个类的一样，而且我们可以使用this关键字和调用所有public方法。

二、扩展函数的使用

（1）函数的扩展

简单来说，Kotlin扩展函数允许我们在不改变已有类的情况下，为类添加新的函数。例如，我们能够为Activity中添加新的方法，让我们以更简单术语显示toast，并且这个函数不需要传入任何context，它可以被任何Context或者它的子类调用，比如Activity或者Service：

fun Context.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT) {
 Toast.makeText(this, message, duration).show()
}1
2
3

当然你也可以这样写：

fun Activity.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT){
 Toast.makeText(this, message, duration).show()
}1
2
3

对参数的解释：
- Activity：表示函数的接收者，也就是函数扩展的对象
- . ：扩展函数修饰符
- toast：扩展函数的名称

我们可以在任何地方（例如在一个工具类文件中）声明这个函数，然后在我们的Activity中将它作为普通方法来直接使用（这里的两种使用方式后文会做解释）：

override fun onCreate(savedInstanceState: Bundle?) { 
 super<BaseActivity>.onCreate(savedInstanceState)
 toast("This is onCreate!!")
 toast("Hello world!", Toast.LENGTH_LONG)
}1
2
3
4
5

当然了，Anko已经包括了自己的toast扩展函数，跟上面这个很相似（关于Anko是什么，你可以看我的这篇文章。。。）。Anko提供了一些针对CharSequence和resource的函数，还有两个不同的toast和longToast方法：

toast("Hello world!")
longToast(R.id.hello_world)1
2

有一点值得注意：扩展函数并不是真正地修改了原来的类，它的这些作用效果是以静态导入的方式来实现的。扩展函数可以被声明在任何文件中，因此有个通用的方式是把一系列有关的函数放在一个新建的文件里，就像我们刚才所说的工具类当中。

我觉得还是再举几个几个例子来说明一下吧，因为它们完全显示扩展函数的力量。

● 在 Toast 中的高级用法

我们首先看看这个例子：

fun Context.niceToast(message: String,
 tag: String = javaClass<MainActivity>().getSimpleName(),
 length: Int = Toast.LENGTH_SHORT) {
 Toast.makeText(this, "[$className] $message", length).show()
}1
2
3
4
5

我们增加了一个默认值是类名的参数，如果这是在Java中的话，那么总数开销会以几何形式增长，而现在我们可以通过以下方式调用：

聊聊分布式事务，再说说解决方案

Tue, 09 Jan 2018 11:31:21 +0800

前言

分布式事务是企业集成中的一个技术难点，也是每一个分布式系统架构中都会涉及到的一个东西，特别是在微服务架构中，几乎可以说是无法避免，本文就分布式事务来简单聊一下。

数据库事务

在说分布式事务之前，我们先从数据库事务说起。数据库事务可能大家都很熟悉，在开发过程中也会经常使用到。但是即使如此，可能对于一些细节问题，很多人仍然不清楚。比如很多人都知道数据库事务的几个特性：原子性(Atomicity )、一致性( Consistency )、隔离性或独立性( Isolation)和持久性(Durabilily)，简称就是ACID。但是再往下比如问到隔离性指的是什么的时候可能就不知道了，或者是知道隔离性是什么但是再问到数据库实现隔离的都有哪些级别，或者是每个级别他们有什么区别的时候可能就不知道了。

本文并不打算介绍这些数据库事务的这些东西，有兴趣可以搜索一下相关资料。不过有一个知识点我们需要了解，就是假如数据库在提交事务的时候突然断电，那么它是怎么样恢复的呢？为什么要提到这个知识点呢？因为分布式系统的核心就是处理各种异常情况，这也是分布式系统复杂的地方，因为分布式的网络环境很复杂，这种“断电”故障要比单机多很多，所以我们在做分布式系统的时候，最先考虑的就是这种情况。这些异常可能有机器宕机、网络异常、消息丢失、消息乱序、数据错误、不可靠的TCP、存储数据丢失、其他异常等等…

我们接着说本地事务数据库断电的这种情况，它是怎么保证数据一致性的呢？我们使用SQL Server来举例，我们知道我们在使用 SQL Server 数据库是由两个文件组成的，一个数据库文件和一个日志文件，通常情况下，日志文件都要比数据库文件大很多。数据库进行任何写入操作的时候都是要先写日志的，同样的道理，我们在执行事务的时候数据库首先会记录下这个事务的redo操作日志，然后才开始真正操作数据库，在操作之前首先会把日志文件写入磁盘，那么当突然断电的时候，即使操作没有完成，在重新启动数据库时候，数据库会根据当前数据的情况进行undo回滚或者是redo前滚，这样就保证了数据的强一致性。

接着，我们就说一下分布式事务。

分布式理论

当我们的单个数据库的性能产生瓶颈的时候，我们可能会对数据库进行分区，这里所说的分区指的是物理分区，分区之后可能不同的库就处于不同的服务器上了，这个时候单个数据库的ACID已经不能适应这种情况了，而在这种ACID的集群环境下，再想保证集群的ACID几乎是很难达到，或者即使能达到那么效率和性能会大幅下降，最为关键的是再很难扩展新的分区了，这个时候如果再追求集群的ACID会导致我们的系统变得很差，这时我们就需要引入一个新的理论原则来适应这种集群的情况，就是 CAP 原则或者叫CAP定理，那么CAP定理指的是什么呢？

CAP定理

CAP定理是由加州大学伯克利分校Eric Brewer教授提出来的，他指出WEB服务无法同时满足一下3个属性：

一致性(Consistency) ：客户端知道一系列的操作都会同时发生(生效)
可用性(Availability) ：每个操作都必须以可预期的响应结束
分区容错性(Partition tolerance) ：即使出现单个组件无法可用,操作依然可以完成

具体地讲在分布式系统中，在任何数据库设计中，一个Web应用至多只能同时支持上面的两个属性。显然，任何横向扩展策略都要依赖于数据分区。因此，设计人员必须在一致性与可用性之间做出选择。

这个定理在迄今为止的分布式系统中都是适用的！为什么这么说呢？

这个时候有同学可能会把数据库的2PC（两阶段提交）搬出来说话了。OK，我们就来看一下数据库的两阶段提交。

对数据库分布式事务有了解的同学一定知道数据库支持的2PC，又叫做 XA Transactions。

MySQL从5.5版本开始支持，SQL Server 2005 开始支持，Oracle 7 开始支持。

其中，XA 是一个两阶段提交协议，该协议分为以下两个阶段：

第一阶段：事务协调器要求每个涉及到事务的数据库预提交(precommit)此操作，并反映是否可以提交.
第二阶段：事务协调器要求每个数据库提交数据。

其中，如果有任何一个数据库否决此次提交，那么所有数据库都会被要求回滚它们在此事务中的那部分信息。这样做的缺陷是什么呢? 咋看之下我们可以在数据库分区之间获得一致性。

我们JAVA开发学习的七大作为

Wed, 29 Nov 2017 19:15:12 +0800

Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。以下是小编搜索整理的关于JAVA开发学习的七大步骤，供参考借鉴，希望对大家有所帮助!

1、多动手

　　学编程语言不仅仅是从理论上的学习，更重要的是要利用这门语言为你的思想服务。理解这门语言是首要的，但是要达到心领神会、融会贯通就必须勤动手，多去时间，多编一些例子。计算机科学是注重实践的学科，成功的软件开发人员无不经过大量的上机锻炼，只有理论和实践相结合才能真正掌握只是和技能。

　　2、多动脑

　　对于Java语言的学习，不仅仅是对语言本身的学习，更重要的是面向对象思想的简历过程，如果想把Java学习提升到一个更高的层次，Java私塾建议从一开始就用面向对象的思维方式去面对你所接触的每件事。

　　3、多查API文档

　　Java提供了大量的类以满足网络化、多线程、面向对象的需要。这就是J2SEAPI，它是Java编程的基本方法，也是编程过程中所不断利用的资源。Java的学习过程不仅仅是基本语法的学习，更多的是去学习和掌握它所提供的API类库。对于所接触到的类，方法，都去仔细去阅读文档的说明，再用自己编写的实例去此时一下。

　　4、约束自己，规范编码习惯

　　养成良好的编码习惯对于一个程序员来讲具有相当大的意义。一方面良好的编程习惯对于减少编码过程中一些人为的错误能起到主动避免的作用;另一方面一段程序写的好坏，不仅仅是功能上的实现，更主要的是可读性，可维护性，没有任何人愿意去阅读一段没有顺序，杂乱无章的代码。建议大家在编码的时候要时刻想到：如果这段代码给别人看，别人是否看得懂，条理是否清楚。

　　5、用有意义的名字

　　名字，是一个标识，是一种有内涵的简单表述。在编写程序的过程中，为每个类、每个方法起一个有意义的名字。在程序阅读的过程中，看到这个名字就可以知道她多完成的功能。

　　6、添加适量的注释

　　注释不仅仅是对程序逻辑处理的一种注释，更多的是提高了程序的可读性和可维护性。做为一个软件产品，哪怕只是一个小小的功能的实现，其中不同的变量及方法可能很多，虽然在命名的过程中要使用有意义的名字，但也不能完全涵盖变量及方法的功能及内涵，多为了提高程序的可读性，添加一定的注释是非常有必要的。合理的注释不仅能起到美化程序的作用还能提高程序可读性和维护性。

　　7、相信自己

　　相信自己包括两方面，一是相信自己的能力，二是相信自己的答案。

　　相信自己的能力就是要相信自己具有解决问题的能力。一个程序员的好坏并不是直接决定于是否能编写出好的代码，更重要的是能否自己去解决调试过程中遇到的任何问题，很少有一个程序员写出的代码一次成功，只有在不断的调试，修正中才能编写出真正的好代码。调试、解决问题的过程就是自己学习提高的过程。

　　相信自己的答案就是要相信自己的程序运行的结果。对于不同的问题在不同的资料上可能有不同的答案，就像小马过河一样，不同的人可能有不同的答案，所以不要去盲目的相信任何人，要相信自己。

五分钟学会 Kotlin 语法

Wed, 29 Nov 2017 11:03:22 +0800

为什么使用Kotlin
项目一期在收尾了终于有时间折腾了，一个多月以来Kotlin从入门到现在，坚持用来开发的切身感受。因为语法与Java的区别挺大的一开始很想放弃，如果不是因为项目在使用，想必很少人会尝试这样一门小众语言，但是习惯后会发现这些年究竟浪费多少时间在写无用的Java代码了，Kotlin在兼容Java的基础上还能大大提升开发效率。Kotlin有许多特性但对于开发来说，快速适应和学习更为重要，很多时候我们都是在不明白其原因就开始使用的，正如我们不可能把Retrofit原理研究透才使用它。只要它足够稳定成熟，并能有效的提升开发效率都是值得尝试的。鄙人不才，目前使用Kotlin的原因主要是因为它语法简洁，支持lambda表达式，强大的when语法，不用写分号结尾，光是这些就足以让我喜欢Kotlin。至于空安全之类的特性，毕竟服务端数据类型太多null了并没多大感触，这些特性在实际应用中潜移默化的就吸收了，以至于现在遇到几个Java编写的代码，都有些不适应了。
修改说明
突然火了一脸懵逼，Google IO的影响真是不容小觑。避免误人子弟还是修改下比较好，也就把上一篇文章的基础知识也搬迁过来，对条件判断when还有空判断处理进行了修改，添加了lambda说明，移除过期链接。
Kotlin 基本语法
先说个学习Kotlin语法的小窍门，将代码用Java写好，然后Code/Conver Java File to Kotlin File转换成Kotlin代码，或者将Java代码复制到Kotlin文件会提示转换也是挺方便的，比较差异很容易就能理解了，一开始难免不适应习惯后相信你一定会喜欢上Kotlin
1). 定义
忘掉Java的那一套写法不然会很不适应的，Kotlin有自己的特性不该被Java的思维所束缚。在Kotlin中常量用val声明，变了用var声明，关键字在前面，类型以冒号:隔开在后面，也可以省略直接赋值，类型后带问号?表示可为空类型(默认空安全)。

常量val延迟加载by lazy{}，默认线程安全关闭线程安全lazy(LazyThreadSafetyMode.NONE){}，变量var延迟加载lateinit。
//常量数组int[][][] arrs = new int[3][2][1];
val arrs = Array(3) { Array(2) { IntArray(1) } }
//空安全变量
var str: String = "hello"
var str1 = "word"
//可为空字符串变量
var str2: String? = null


2). 条件
if...else 正常使用，不过移除了switch用更强大的when替代，when子式可以是常量、变量、返回数值的表达式、返回Boolean值的表达式，强大到用来替换if...else if
// 测试值 x = 0, -1, 1, 2, 3, 6, 10
var x = 10
when (x) {
 //常量
 2 -> println("等于2")
 //数值表达式
 if (x > 0) 1 else -1 -> println("大于0并等于1，或小于0并等于-1")
 //Boolean类型表达式
 in 1..5 -> println("范围匹配1-5")
 !in 6..9 -> println("不是6-9")
 is Int -> println("类型判断")
 else -> println("else")
}
// 代替if...else if
when{
 x > 6 && x <= 10 -> println("大于6小于等于10")
 x < 6 -> println("小于6")
 else -> println("else")
}

3). 循环

java mail实现Email的发送,完整代码

Sun, 26 Nov 2017 18:34:36 +0800

1、对应用程序配置邮件会话

javax.mail.Session保存邮件系统的配置属性和提供用户验证的信息，发送email首先要获取session对象。

(1)Session.getInstance(java.util.Properties)获取非共享的session对象

(2)Session.getDefaultInstance(java.utilProperties)获取共享的session对象

两者都必须建立Properties prop=new Properties()对象;

注意：一般对单用户桌面应用程序使用共享Session对象。

用SMTP协议发送Email时通常要设置mail.smtp.host(mail.protocol.host协议特定邮件服务器名)属性。

prop.put("mail.smtp.host","smtp.mailServer.com");

Session mailSession=Session.getInstance(prop);

注意：在真正使用创建的过程中，往往会让我们验证密码，这是我们要写一个密码验证类。javax.mail.Authenticator是一个抽象类，我们要写MyAuthenticator的密码验证类，该类继承Authenticator实现：

protected PasswordAuthentication getPasswordAuthentication(){
return new PasswordAuthentication(String userName, String password);
}

这时我们创建Session对象：

Session mailSession=Session.getInstance(prop,new MyAuthenticator(userName,Password));

并且要设置使用验证：prop.put("mail.smtp.auth","true");

使用 STARTTLS安全连接:prop.put("mail.smtp.starttls.enable","true");

2、配置邮件会话之后，要编写消息

要编写消息就要生成javax.mail.Message子类的实例或对Internet邮件使用javax.mail.interet.MimeMessage类。

(1)建立MimeMessage对象

MimeMessage扩展抽象的Message类，构造MimeMessage对象：

MimeMessage message=new MimeMessage(mailSession);

(2)消息发送者、日期、主题

message.setFrom(Address theSender);

message.setSentDate(java.util.Date theDate);

message.setSubject(String theSubject);

(3)设置消息的接受者与发送者（寻址接收）

setRecipient(Message.RecipientType type , Address theAddress)、setRecipients(Message.RecipientType type , Address[] theAddress)、addRecipient(Message.RecipientType type , Address theAddress)、addRecipients(Message.RecipientType type,Address[] theAddress)方法都可以指定接受者类型，但是一般用后两个，这样可以避免意外的替换或者覆盖接受者名单。定义接受者类型：

Message.RecipientType.TO：消息接受者

Message.RecipientType.CC：消息抄送者

Message.RecipientType.BCC：匿名抄送接收者(其他接受者看不到这个接受者的姓名和地址)

(4)设置消息内容

JavaMail基于JavaBean Activation FrameWork(JAF)，JAF可以构造文本消息也可以支持附件。

设置消息内容时，要提供消息的内容类型-----即方法签名:

Java学习笔记--SSH框架整合(struts2、spring4、hibernate5)

Sun, 19 Nov 2017 19:53:27 +0800

一、SSH三大框架的概述

　　ssh为 struts+spring+hibernate的一个集成框架，是目前较流行的一种Web应用程序开源框架。

　集成SSH框架的系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层（实体层），以帮助开发人员在短期内搭建结构清晰、可复用性好、维护方便的Web应用程序。

struts2：　　

　　　　1、什么是struts2：

　　　　　　Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts 2可以理解为WebWork的更新产品。虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2的变化很小。

　　　　2、struts2框架的运行结构：

　　　　解析：客户端发送请求(HttpServletRequest)到服务器，服务器接收到请求就先进入web.xml配置文件看看有没有配置过滤器，发现有struts2的过滤器，然后就找到struts.xml配置文件，struts.xml配置文件里有定义一个action，然后就去找到类名叫IndexAction这个类(此action类必须是继承ActionSupport接口)，并且实现了execute()方法，返回一个字符串为"success"给struts.xml配置文件，struts.xml配置文件的action会默认调用IndexAction类的execute()方法，result接收到了返回的字符串，然后查找结果字符串对应的(Result），result就会调用你指定的jsp页面将结果呈现，最后响应回给客户端。

　　spring：

　　　1、什么是spring?

　　　　　　Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。　　　　　　　

　　　　　　　　轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

　　　　　　　　控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

　　　　　　　　面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

　　　　　　　　容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

　　　　　　　　框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

　　　　2、spring的流程图：　　　　

　　　　解析：上图是在struts结构图的基础上加入了spring流程图，在web.xml配置文件中加入了spring的监听器，在struts.xml配置文件中添加“<constant name="struts.objectFactory" value="spring" />”是告知Struts2运行时使用Spring来创建对象，spring在其中主要做的就是注入实例，将所有需要类的实例都由spring管理。

　　hibernate：

　　　1、什么是hibernate？

　　　　Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

【SSH网上商城项目实战30】项目总结（附源码下载地址）

Sun, 19 Nov 2017 19:52:46 +0800

0. 写在前面

　　友情提示：点击>>下载地址<<下载源码。
　　项目基本完成了，加上这个总结，与这个项目相关的博客也写了30篇了，积少成多，写博客的过程是固化思路的一个过程，对自己很有用，同时也能帮助别人。顺便说个题外话，在学习的过程中肯定会遇到很多异常出现，我们要做的首先是定位这个异常，一般异常的后面都会跟一个或多个Caused by：xxx，这些都是引起异常的原因，一般我们找最下面的一个Caused by，那里往往才是问题的根源。如果自己解决不了，可以去谷歌、百度搜索（搜索的时候别一大堆异常往上一贴，注意搜关键的部分！），一般我们遇到的问题，99.9%前人都遇到过，基本都能解决，我遇到不能解决的问题基本都是这么干的，自己解决的多了，就有感觉了~最后希望大家在阅读我的博客时会有所收获！　　
　　废话就不说了，下面总结一下这个网上商城的项目，我不会面面俱到，主要分为几个模块来总结，包括用到了哪些技术等等，具体的细节我会在文章中附上快速链接，大家可以查看具体的某篇博文。
　　回忆一下这个项目，总共可以分为这些主要的模块：

项目环境的搭建
搭建后台管理系统
搭建前台显示页面
购物车相关功能
在线支付功能
邮件和短信的发送功能
域名的申请和项目的部署
表单验证和报表的显示

　　下面针对每个模块，做一下具体的分析。

1. 项目环境的搭建

　　这是每个工程都少不了的环节，而且也会出现很多乱七八糟的问题，刚开始学SSH的时候，总是苦于搭建环境，因为不太熟练，但是熟练了就好了，主要是要“有节奏的”去搭建，也就是说搭建一个环境工程得一步步来，一点点的搭，很多人上来就把jar包啪叽一下全导进去了，然后什么配置文件啊啪叽一下全写好或者从其他地方粘贴来，然后一运行，挂了……然后各种去找问题，何苦呢？这样的话就算搭建10次也不能得心应手。饭要一口口的吃，路要一步一步的走。
　　
　　SSH的环境搭建，我个人遵循的流程是：

Spring –> Hibernate –> Spring整合Hibernate –> Struts2 –> Spring整合Struts2

　　每一步做完写个测试类测试一下，这很重要，因为一步步往下走的话，出错了也知道错在哪一步，去哪找问题，最重要的是，这种流程熟练了，下次再搭环境的时候就易如反掌了。关于SSH环境搭建的详细信息请看下面的博文：
　　
　　整合Struts2、Hibernate4.3和Spring4.2
　　基本增删查改、Service和Action的抽取以及使用注解替换xml

2. 搭建后台管理系统

　　后台管理系统我用的是EasyUI搭建的，说真的，EasyUI我也是一知半解，前端的东西我了解的都不深，但是懂一点，具体用的时候也是各种去查的，也没系统的学过，所以没有一个良好的知识体系，但是也不影响去玩。程序猿都喜欢说玩一个技术啥的，听起来好像挺高大上的，慢慢的我也受到一些影响，也喜欢这么说了，不过我对于前端就真的在玩了……　　
　　jQuery EasyUI是一组基于jQuery的UI插件集合体，而jQuery EasyUI的目标就是帮助web开发者更轻松的打造出功能丰富并且美观的UI界面。开发者不需要编写复杂的javascript，也不需要对css样式有深入的了解，开发者需要了解的只有一些简单的html标签。　　
　　EasyUI的请求都是Ajax请求，不会有新的页面出来，全都都在tab选项卡中或者弹出一个窗口之类的。后台管理系统主要分为三部分：商品的类别管理、商品的管理以及销售管理。销售管理放在最后再说。

2.1 商品类别的管理

　　该部分主要涉及到了EasyUI环境和后台框架的搭建、数据库的级联查询和分页、DataGrid数据显示、Struts2整合json以及商品类别的添加、删除、更新和搜索。这也是遵循了该部分的一个完成的顺序。　　
　　DataGrid以表格的形式展示数据，开发人员不需要具备特定的知识就可以操作它，它有个很好的帮助文档，比较详细，在本项目中我也介绍了创建DataGrid的几种方式，并且也简单介绍了一下DataGrid的部分属性，算是入门吧，我也是入门，多多开发才能掌握这个技术。　　
　　类别的添加、删除、更新和搜索功能，主要都是利用EasyUI自带的验证功能，添加商品类别的时，验证输入框的输入是否正确，是否必填等；删除时是否先选中的某一行或某几行；更新的时候每次只能更新一行等，所有这些都是Ajax请求。　　
　　关于这部分内容的详细信息，我已经归类了，请参考这些博文：
　　
　　使用EasyUI搭建后台页面框架
　　 EasyUI菜单的实现
　　数据库的级联查询和分页
　　基于DataGrid的数据显示功能
　　 Struts2和Json的整合　　
　　 DataGrid实现查询和删除功能
　　 DataGrid实现添加和更新功能
　　　　
　　下面是我自己遇到的问题：
　　Struts2和Json整合中的懒加载异常问题
　　 Hibernate4执行save()或update()无效　　

2.2 商品的管理

　　商品的管理也有添加删除等操作，跟类别管理道理上是一样的，有个地方就是商品的添加，需要上传商品的照片，这里涉及到了Struts2实现文件上传的功能，我们需要在服务器端建一个文件夹专门用来存储上传文件的，然后写一个model来接收文件，关于文件上传，要专门写一个工具类，项目中开发就是这样的，共性的代码一定要抽取，哪怕只有一句代码也要抽取！这是习惯，也是必须要做的。具体细节参下面列出的这些的博文：
　　
　　商品类基本模块的搭建　　
　　查询和删除商品功能的实现　　
　　添加和更新商品功能的实现　　
　　 Struts2实现文件上传功能　　

3. 搭建前台显示页面

　　当然，前台的页面不是我设计的，这一块内容我总结的是跟前台显示相关的一些后台技术，比如：监听器获取首页数据、定时器同步首页数据、Hibernate二级缓存处理热门商品的缓存等。
　　以前在学习serlvet的时候，首页显示数据我是这么干的，用一个frame，右边显示数据，那么index.jsp中右边的部分我跳转到一个servlet，然后servlet中去数据库中取出所有商品，放到request域中带过去新的jsp页面显示。这虽然能实现，但是很笨。在这里我用了监听器来干这件事，首先自己定义一个监听器，在项目启动的时候把数据库中所有商品信息给取出来，放到application域中，然后首页中直接用EL表达式从application域中去取即可。　　
　　还有个问题，当我在管理系统中添加一个新的商品时，我必须要重启一下tomcat才能将新的商品加到application域中，因为第一次取出来后就一直在application域中了，就定死了，后面新添加的就不在application域里面，为了解决这个问题，我使用了定时器来同步首页数据。于是改写了之前写好的监听器，在监听器中设置一个定时器，获取数据库中商品的数据的代码放到定时器任务中，第一次开启立马执行，然后每6个小时执行一次（时间可以自己随便设定），也就是说每6个小时重新获取一下数据库中的商品，存到application域中。一般网站也是这么干的，像CSDN的个人博客主页也是，每天更新一次排名，大概是晚上10点左右吧，具体时间我忘了。那个时候刷新就会看到数据的更新，这样也减小了服务器的压力。

　　该部分具体的技术细节，参见下面这几篇博文：
　　
　　使用监听器获取显示在首页的数据　　
　　监听器如何获取Spring的配置文件　
　　线程、定时器定时同步首页数据　
　　 Hibernate二级缓存处理首页的热门显示

4. 购物车相关功能

　　购物车的部分主要涉及到的技术有：后台的处理购物车和购物项的逻辑、过滤器判断登陆、订单的级联入库以及页面缓存的问题。
　　购物车的话主要是后台的一些实现逻辑了，购物车里需要有购物项，啥意思呢？我们在天猫上买东西都知道，可以把不同的商品都放到购物车里，然后购物车里有很多商品，每个商品的数量又可以有多个，每个商品及其相关信息就是一个购物项，所以添加购物车的时候，我们首先要完成一个购物项，再将此购物项添加到购物车里。
　　当用户想要结算的时候，我们得首先判断用户有没有登陆，这用到了过滤器技术，专门过滤某一类的url，在过滤器中判断当前session中有没有user对象，如果有说明登陆过了，直接放行就行，如果没有则跳转到登陆页面让用户登陆，登陆完成后跳转到用户原来想去的页面。也就相当于门卫一样~看大门的~
　　刚刚也提到了，订单信息包含购物车和购物项，那么我们在订单入库的时候，就要考虑到它们的级联问题，我们可以通过在两者的POJO中设置相应的注解属性即可，但是有个前提，像这种有外键关联的，在入库之前都要将对应的POJO中的外键部分的字段赋好值，比如订单要将订单项加进去，订单项中的订单属性也得赋好值，然后才可以交给Hibernate，Hibernate根据配置好的注解（或者xml文件）将它们一起级联入库。
　　页面缓存的问题指的是，当用户确认了订单后，如果点后退，又会回到订单确认页面，刚刚的订单确认页面又出来了，而且session还在，信息还是刚刚的信息，这明显不是我们想要的结果。我们需要在前台和后台同时进行处理才行。
　　该部分具体技术细节，请参见下面的几篇博文：

SSH框架整合demo

Sun, 19 Nov 2017 19:49:15 +0800

Struts、Spring、Hibernate整合

一、创建web工程，搭建Struts框架开发环境：

这里只导入了项目中所需要的重要的jar包，以后根据业务要求继续导入相关的包。

步骤1：:导入struts框架所需的jar包
步骤2：在web.xml中配置struts2.0主过滤器
步骤3：导入struts.xml配置文件

web.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://java.sun.com/xml/ns/javaee
https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

struts.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"https://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<constant name="struts.devMode" value="true" />
<constant name="struts.action.extension" value="action"/>
<package name="default" namespace="/" extends="struts-default">
</package>
</struts>

二、搭建Hibernate开发环境：

创建数据库：

这里只导入了项目中所需要的重要的jar包，以后根据业务要求继续导入相关的包。

工程目录：

hibernate.cfg.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.url">jdbc:mysql://localhost:3306/xbmuoa</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 根据映射产生表结构的类型:
create-drop:木有表结构创建，下次启动时删除重新创建。适合学习阶段
create：只做创建
update：探测表结构够的变化，对于数据库没有的，进行更新操作。适合学习阶段
validate：对比与数据库的结构
-->
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
</session-factory>
</hibernate-configuration>

Person.hbm.xml（暂时性先写个映射文件的模板）

[html] view plain copy

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.xbmu.oa.domain">
</hibernate-mapping>

三、搭建Spring开发环境：

这里只导入了项目中所需要的重要的jar包，以后根据业务要求继续导入相关的包。

applicationContext.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:context="https://www.springframework.org/schema/context"
xmlns:tx="https://www.springframework.org/schema/tx"
xsi:schemaLocation="https://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
https://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
https://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<context:component-scan base-package="cn.xbmu.oa"></context:component-scan>
</beans>

以上已经将Struts、Spring、Hibernate开发所需要的jar包及其配置文件已经配置到web工程中了。

接下来，我们两两整合在一起。

四、Spring与Hibernate整合：

让Spring来管理SessionFactory和事务。

工程目录：

applicationContext.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:context="https://www.springframework.org/schema/context"
xmlns:tx="https://www.springframework.org/schema/tx"
xsi:schemaLocation="https://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
https://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
https://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<context:component-scan base-package="cn.xbmu.oa"></context:component-scan>
<context:property-placeholder location="classpath:jdbc.properties" />
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="jdbcUrl" value="${jdbcUrl}"></property>
<property name="driverClass" value="${driverClass}"></property>
<property name="user" value="${username}"></property>
<property name="password" value="${password}"></property>
<property name="initialPoolSize" value="3"></property>
<property name="minPoolSize" value="3"></property>
<property name="maxPoolSize" value="5"></property>
<property name="acquireIncrement" value="3"></property>
<property name="maxStatements" value="8"></property>
<property name="maxStatementsPerConnection" value="5"></property>
<property name="maxIdleTime" value="1800"></property>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager" />
</beans>

jdbc.properties

[plain] view plain copy

jdbcUrl = jdbc:mysql:///xbmuoa
driverClass = com.mysql.jdbc.Driver
username = root
password = root

SpringTest.java

[java] view plain copy

package cn.xbmu.oa.test;
import org.hibernate.SessionFactory;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
private ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//测试SessionFactory
@Test
public void testSessionFactory(){
SessionFactory sessionFactory = (SessionFactory) ac.getBean("sessionFactory");
System.out.println(sessionFactory);
}
}

使用Junit测试，结果：

启动tomcat没有报错，说明以上环境的搭建都完全正确，并进行测试，也没有报错。

User.java

[java] view plain copy

package cn.xbmu.oa.domain;
public class User {
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

User.hbm.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.xbmu.oa.domain">
<class name="User">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
</hibernate-mapping>

记得在hibernate.cfg.xml文件中引入映射文件。

TestService.java

[java] view plain copy

package cn.xbmu.oa.test;
import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import cn.xbmu.oa.domain.User;
@Service("testService")
public class TestService {
@Resource
private SessionFactory sessionFactory;
@Transactional
public void saveTwoUser(){
Session currentSession = sessionFactory.getCurrentSession();
currentSession.save(new User());
int i = 1 / 0;//这里会抛出异常
currentSession.save(new User());
}
}

SpringTest.java

[java] view plain copy

package cn.xbmu.oa.test;
import org.hibernate.SessionFactory;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
private ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//测试SessionFactory
@Test
public void testSessionFactory(){
SessionFactory sessionFactory = (SessionFactory) ac.getBean("sessionFactory");
System.out.println(sessionFactory);
}
//测试事务
@Test
public void testTransaction(){
TestService testService = (TestService) ac.getBean("testService");
testService.saveTwoUser();
}
}

测试事务，报错，因为在 int i = 1 / 0这里发生了异常。

查询数据库xbmuoa中的表，没有数据

我们注释掉 int i = 1 / 0;这句代码，重新测试，成功。

查询user表，里面已经有了保存的数据

我们，继续打开抛异常的语句，再测试；再注释抛异常的代码，再测试。查看表中的数据，发现了事务回滚了。

到此为止，我们顺利的将Spring与Hibernate整合在一起了。并测试了SessionFactory与事务，都正常。

五、Spring与Struts整合：

为了说明白，我们在整合之前写个Action，整合之后写个Action，看看他们之间的区别：

整合之前：

TestAction.java

[java] view plain copy

package cn.xbmu.oa.test;
import com.opensymphony.xwork2.ActionSupport;
public class TestAction extends ActionSupport {
@Override
public String execute() throws Exception {
System.out.println("---------->TestAction execute()");
return "success";
}
}

struts.xml

[html] view plain copy

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"https://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<constant name="struts.devMode" value="true" />
<constant name="struts.action.extension" value="action"/>
<package name="default" namespace="/" extends="struts-default">
<action name="test" class="cn.xbmu.oa.test.TestAction">
<result name="success">/test.jsp</result>

Java精选笔试题

Sat, 11 Nov 2017 20:50:26 +0800

合抱之木，生于毫末；九层之台，起于垒土；千里之行；始于足下。赶快测测你的Java基础知识掌握的如何？

1，volatile关键字是否能保证线程安全？（）

>>>>

答案：否

volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的读取值，而非cache中。但多个线程对volatile的写操作，无法保证线程安全。

假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值，在线程1对count进行修改之后，会write到主内存中，主内存中的count变量就会变为6；线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6；导致两个线程及时volatile关键字修改之后，还是会存在并发的情况。

2，下面哪个流类属于面向字符的输入流( )

A、BufferedWriter

B、FileInputStream

C、ObjectInputStream

D、InputStreamReader

>>>>

答案：D

Java小技巧，从运行、控制到框架

Wed, 08 Nov 2017 19:17:52 +0800

1. JVM相关

JVM作为java运行的基础，很难相信对于JVM一点都不了解的人可以把java语言吃得很透。我在面试有超过3年Java经验的开发者的时候， JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证java开发能力的高低。

在JVM这个大类中，我认为需要掌握的知识有：

JVM内存模型和结构

GC原理，性能调优

调优：Thread Dump，分析内存结构

class 二进制字节码结构， class loader 体系， class加载过程，实例创建过程

方法执行过程

Java各个大版本更新提供的新特性(需要简单了解)

2. Java的运行（基础必备）

这个知识点是最最基本的java开发者需要掌握的，初学java，第一个肯定是教你如何在命令行中执行java程序，但是很多人一旦把java学完了，IDE用上了，就把这个都忘了。为什么强调要知道这个呢，知道了java最纯粹的启动方式之后，你才能在启动出问题的时候，去分析当时启动的目录多少，执行命名如何，参数如何，是否有缺失等。这样有利于你真正开发中去解决那些奇奇怪怪的可能和环境相关的问题。

在这里需要掌握的知识有：

javac 编译java文件为 class 文件

java 命令的使用，带package的java类如何在命令行中启动

java程序涉及到的各个路径(classpath， java。library。path， java运行的主目录等)

3. 数据类型

这条没有什么好多说的，无非就是Java中的基本类型和对象类型的掌握。可以再了解一些JDK如何自动转换方面的知识，包括装箱拆箱等，还要注意避免装箱之后的类型相等的判断

主要知识点：

基本类型： int， long， float， double， boolean ，。。。

Spring 知识点提炼

Tue, 07 Nov 2017 20:16:00 +0800

1. Spring框架的作用

轻量：Spring是轻量级的，基本的版本大小为2MB
控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
面向切面的编程AOP:Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
容器：Spring包含并管理应用中对象的生命周期和配置
MVC框架： Spring-MVC
事务管理：Spring提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务JTA
异常处理：Spring提供方便的API把具体技术相关的异常

2. Spring的组成

Spring由7个模块组成：

Spring Core: 核心容器提供 Spring 框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

java多线程高级教程，这些你都懂了吗？

Thu, 02 Nov 2017 23:21:04 +0800

一、countdownLatch和cyclicbarrier（这两个做多线程控制很好用，工作中会经常用到）

countdownLatch：主线程阻塞，当多个线程countdown到0，主线程执行；

cyclicbarrier：多个线程等待，当都处于等待状态了一起执行（类似于赛跑机制）

countdownLatch

cyclicbarrier

二、volatile和threadlocal

这两个也要很好掌握，不仅常用，而且面试时候也经常问到！

volatile:使属性可见性。有个属性是共享属性，这个关键字会在每个线程内开一块内存，每次子线程都会从主线程拿最新的属性放到内存中。但是有个问题，他只是拿最新的，比如：计数器，每个线程都执行+1操作。一个线程+1，另外两个同时读取这个属性，那么不会加2次，而是只加一次，这就是valatile不能保证原子性的原因。

threadlocal：用于做方法外的全局属性。这个跟volatile刚好相反，使全局变量独立，每个线程里都有一份独立副本。

这是hibernate的源码，如果当前线程没有session就openSession放到ThreadLocalMap中，每个线程的session都是独立的不会相互受影响。

三、AtomicInteger：支持原子性计数器。

之前说volatile不能作为计数器，那么多线程计数器要用atomic类的AtomicInteger

四、并发类容器

ConCurrentHashMap、CopyAndWriteArrayList、CopyAndWriteArraySet。

ConCurrentHashMap（底层分成16个hashtable来保证并发）读支持高并发读，写和删除时候只支持16个线程，所以一般也要上锁； copyandwrite支持高并发读，写的话要加锁（原理是，写的时候赋值一个容器，写好了把指针指向新容器并且删除原容器）

map、list、set都有并发类容器。面试时候经常会问hashmap和ConCurrentHashMap区别。这个demo我就不写了，用法和我们平时用的集合都一样，只是他们不会造成线程不安全。

五、并发类队列

阻塞的意思是，当达到队列最大容量或者为空，线程还往里加东西或取东西会被阻塞；有界意思，可以设置队列大小。

（非阻塞队列）ConcurrentLinkedQueue无阻塞无界限队列（高并发性能最好，peek取出不删除，poll取出删除），

（阻塞队列）ArrayBlockingQueue阻塞有界队列，LinkBlockingQueue阻塞无界队列（生产者消费者首选，take方法会阻塞，poll方法没有就返回null）。

这里我们以最经典的生产者消费者模式作为例子

这里我们顺便做一个延伸，我们用的所有线程池，包括面试时候经常问的要你自定义一个线程池怎么做？我们先看一下线程池的源码。

也就是说线程池也是用并发队列作为线程的容器。我们自定义时候也只需要重现实例化ThreadPoolExcutor，设置我们自己需要的参数即可。

六、分布式锁

这个其实已经不属于java代码范畴，但是我上一篇讲基础的时候，一些兄弟说我说的太简单，另一些又说太难，所以我加了一个分布式锁，希望能满足更多人需求。

分布式锁，主要用在分布式集群上，既然是分布式，那就有多个jvm，即使你代码写出花来也不能控制。所以只有一个办法就是借助第三方工具。比如memcache、redis、zk

1. 首先明确一点，有人可能会问是否可以考虑采用ReentrantLock来实现，但是实际上去实现的时候是有问题的，ReentrantLock的lock和unlock要求必须是在同一线程进行，而分布式应用中，lock和unlock是两次不相关的请求，因此肯定不是同一线程，因此导致无法使用ReentrantLock。

2. 基于数据库表做乐观锁，用于分布式锁。

3. 使用memcached的add()方法，用于分布式锁。

Java入门学习进阶知识点汇总

Wed, 01 Nov 2017 20:04:15 +0800

入门阶段，主要是培养Java语言的编程思想。了解Java语言的语法，书写规范等，掌握Eclipse、MyEclipse等开发工具，编写Java代码的能力。学完这个阶段你应该可进行小型应用程序开发并且可以对数据库进行基本的增删改查管理。

注意：此阶段知识点的学习，需要真实的项目进行驱动学习，让你轻松理解各知识点。

1 计算机基础知识

针对零基础学习的人，从对计算机操作等知识的了解，延伸到Java语言的发展与开发工具的使用上。主要是了解怎样执行计算机命令，认识Java这门语言，感受编程语言Java怎么开发程序。

(1) 计算机基础

零基础学习的人先了解计算机相关知识，进而再去了解Java语言。

(2) DOS常用命令

了解什么是DOS，并掌握DOS控制台的打开方式，同时熟悉常用的DOS命令，例如：盘符切换、进入指定目录、删除文件等，完成使用DOS命令对计算机进行操作和控制。

(3) Java概述

了解Java语言的发展史、Java语言平台版本、Java语言的特点，以及JRE与JDK。JRE是Java的运行环境，JDK是Java开发工具包，它包含了Java的开发工具以及JRE。所以安装了JDK就不用再单独安装JRE了。

(4) JDK环境安装配置

了解了什么是JDK，以及JDK的重要性，下一步我们就来学习如何安装和配置JDK环境。在安装JDK之前，我们首先需要下载JDK，针对不同的系统，我们需要下载不用版本的JDK。

(5) 环境变量配置

了解path、classpath环境变量，理解path变量和classpath变量的作用，并掌握path变量和classpath变量的配置方式。

(6) Java程序入门

当JDK、环境变量配置完毕，我们就可以开始编写Java程序。编写Java程序可以使用如下几种工具：notepad（微软操作系统自带）、Editplus、Notepad++、Eclipse、MyEclipse。

2 编程基础

此模块学习主要是了解编程的具体流程，学习Java基础语法的格式等。具体要掌握不同数据类型的变量定义与使用，掌握不同运算符的运算规则，掌握流程控制语句的执行流程，编写方法的声明与调用，创建数组并访问数组元素等知识。

(1) 注释

在程序开发工程中，用于解释和说明程序的文字我们称之为注释，Java中的注释分为以下几种：单行注释、多行注释、文档注释。

(2) 关键字

了解Java关键字的含义及特点，掌握关键字使用的注意事项。

( 3) 标识符

了解什么是标识符，标识符的组成规则，以及标识符使用时的注意事项。

( 4) 常量与变量

理解常量与变量的含义，并掌握常量与变量的区别、变量的定义格式以及变量的赋值。

( 5) 数据类型

掌握Java语言的数据类型，如基本数据类型：byte、short、int、long、float、double、char、boolean，以及引用类型：类、接口、数组。

Java数据结构与算法

Tue, 31 Oct 2017 18:25:34 +0800

Cany大酋长

刚学习数据结构与算法时，就被告知 “程序=算法+数据结构”，而这段话来自于对点计算机科学家Niklaus Wirth在1976年出版的一本书的书名，后来这句话也成为计算机工作者之间流传的一句名言，小编也用惨痛的经历告诉大家这也是一个很重要的知识点。

那么到底什么是数据结构和算法，数据结构算法又有什么用呢？

首先来说说什么是数据结构，直接上图

从图中我们可以很直观的看出数据结构涵盖的内容。

算法的介绍就相对抽象了，百度百科给出的解释是

算法是对特定问题求解步骤的一种描述，它是指令的有限序列，其中每一条指令表示一个或者多个操作。

但是我们从他的特性来理解就会简单多了。算法主要有五个特性

· 有穷性：指令序列是有限的

· 确定性：每条语句的含义明确，无二义性

· 可行性：每条语句都应在有限的时间内完成

· 输入：零个或者多个输入

· 输出：一个或者多个输出

Java在各个操作系统中的安装方式

Mon, 30 Oct 2017 17:43:48 +0800

前言

Java安装应该是件非常简单的事情，不知何时在Oracle官方下载JDK时，竟然强制要求用户登陆。这样就不能通过Linux命令wget下载了，真是有点让人火大。

想了个办法破解这种恶心的cookies验证行为！

对大数据感兴趣的朋友可以加群大数据视频学习交流群 675590728

Java在Windows中安装
Java在Linux Ubuntu中安装

1 Java在Windows中安装

Java环境安装，是指Java开发环境的安装，包括JDK安装和Java的环境配置。在Windows中，很多的Java应用通过JRE就可以运行。但对Java的开发者来说，我们需要安装JDK，必须Oracle SUN官方发布的JDK。

在Windows系统上安装JDK是件非常简单的事情，对大数据感兴趣的朋友可以加群大数据视频学习交流群 675590728

大家可以下载最新版本的Java SE 8，或者较早的JDK版本。本文中使用的是1.6.0_45版本的JDK。

下载后，双击安装。我安装在目录: D: oolkitjavajdk6

安装好JDK后，配置环境变量：

选择：控制面板 –> 系统和安全 –> 系统属性 –> 高级 –> 环境变量

# 新建JAVA_HOME变量JAVA_HOME=D:	oolkitjavajdk6# 新建PATH变量PATH=D: oolkitjavajdk6in

注：如果PATH变量已存在，则在最后增加JDK的路径，用分号(;)与上个配置做分隔。

保存后，打开CMD命令窗口，测试Java的命令行操作。

# 查看Java安装版本~ C:UsersAdministrator>java -versionjava version "1.6.0_45"Java(TM) SE Runtime Environment (build 1.6.0_45-b06)Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)# 测试Java命令~ C:UsersAdministrator>javaUsage: java [-options] class [args...] (to execute a class) or java [-options] -jar jarfile [args...] (to execute a jar file)where options include: -server to select the "server" VM -hotspot is a synonym for the "server" VM [deprecated] The default VM is server. -cp-classpathA ; separated list of directories, JAR archives, and ZIP archives to search for class files. -D=set a system property -verbose[:class|gc|jni] enable verbose output -version print product version and exit -version:require the specified version to run -showversion print product version and continue -jre-restrict-search | -jre-no-restrict-search include/exclude user private JREs in the version search -? -help print this help message -X print help on non-standard options -ea[:...|:] -enableassertions[:...|:] enable assertions -da[:...|:] -disableassertions[:...|:] disable assertions -esa | -enablesystemassertions enable system assertions -dsa | -disablesystemassertions disable system assertions -agentlib:[=] load native agent library, e.g. -agentlib:hprof see also, -agentlib:jdwp=help and -agentlib:hprof=help -agentpath:[=] load native agent library by full pathname -javaagent:[=] load Java programming language agent, see java.lang.instrument -splash:show splash screen with specified image# 测试Javac命令~ C:UsersAdministrator>javac用法：javac <选项> <源文件>其中，可能的选项包括： -g 生成所有调试信息 -g:none 不生成任何调试信息 -g:{lines,vars,source} 只生成某些调试信息 -nowarn 不生成任何警告 -verbose 输出有关编译器正在执行的操作的消息 -deprecation 输出使用已过时的 API 的源位置 -classpath <路径> 指定查找用户类文件和注释处理程序的位置 -cp <路径> 指定查找用户类文件和注释处理程序的位置 -sourcepath <路径> 指定查找输入源文件的位置 -bootclasspath <路径> 覆盖引导类文件的位置 -extdirs <目录> 覆盖安装的扩展目录的位置 -endorseddirs <目录> 覆盖签名的标准路径的位置 -proc:{none,only} 控制是否执行注释处理和/或编译。 -processor[,,...]要运行的注释处理程序的名称；绕过默认的搜索进程 -processorpath <路径> 指定查找注释处理程序的位置 -d <目录> 指定存放生成的类文件的位置 -s <目录> 指定存放生成的源文件的位置 -implicit:{none,class} 指定是否为隐式引用文件生成类文件 -encoding <编码> 指定源文件使用的字符编码 -source <版本> 提供与指定版本的源兼容性 -target <版本> 生成特定 VM 版本的类文件 -version 版本信息 -help 输出标准选项的提要 -Akey[=value] 传递给注释处理程序的选项 -X 输出非标准选项的提要 -J<标志> 直接将 <标志> 传递给运行时系统

这样我们就在Windows的系统中，配置好了Java环境。

2 Java在Linux Ubuntu中安装

Java安装，指定的是SUN Oracle官方的JDK软件包，而不是Linux Ubuntu系统中通过apt-get安装的OpenJDK。

注：请一定注意版本，必须使用SUN Oracle官方的JDK软件包

在Linux Ubuntu中，下载并安装JDK，这里我选择安装Java SE 1.6.45的64位版本的JDK。

2.1 下载JDK

不知道Oracle官方网站时候调整的JDK下载需要先登陆，因此直接使用wget命令，无法完成JDK的下载。

我们有下面2种解决方法：

1). 从浏览器中登陆下载，然后再传到Linux的服务器

GitHub 上最火的 Java 框架

Sat, 28 Oct 2017 20:30:26 +0800

Java 是目前最需要的编程语言之一。在这里，我们已经挖掘了一些关于框架趋势的有用信息，也就是最受开发者青睐的 Java 框架，名单如下

Spring MVC

网页链接

自从 10 多年前的第一次发布之后，SpringMVC 老当益壮，继续保持着领头羊的地位。在其完全拥抱 MVC 框架之后，Spring 不断的发展与变化着，转变成了一个功能全面的面向互联网应用程序的 Java 框架, 它能提供给软件工程师的是一个用于 Web 应用程序开发的强大工具集，以及针对安全项目的应用程序配置。具有如下特性：

● 简单的 POJO 测试数据注入方式。

● 增强过的模块化，因此拥有更好的代码可靠性。

● 不同模块之间解耦和。

● 能灵活运用的依赖注入（DI）。

Spring Boot

网页链接

Spring Boot 项目旨在简化创建产品级的 Spring 应用和服务。你可通过它来选择不同的 Spring 平台。可创建独立的 Java 应用和 Web 应用，同时提供了命令行工具来允许 'spring scripts'。Spring Boot 不生成代码，完全无需 XML 配置。

历数Java程序员面试失败的5大原因

Fri, 27 Oct 2017 19:31:56 +0800

＃1 说得太少

尤其是那些开放式的问题，如“请介绍下你自己”或“请讲一下你曾经解决过的复杂问题”。面试官会通过你对这些技术和非技术问题的回答来评估你的激情。他们也会通过模拟团队氛围和与你的交流互动来判断你的经验和能力。

所以，仅仅只用两三句话来回答不但不能显示出你对这个专业的兴趣，还会让整个面试过程显得非常无聊。如果你不能很好地说明你的经验、成就和技能可以给企业带来的价值，那么你的竞争力毫无疑问就高不起来。所以，你需要对一些最常见的开放式问答作充分的准备，学会推销自己。

＃2 说得太多

不断地说，不断地说，却并没有什么实质性的内容。换句话说，就是废话连篇，言之无物。如果你不能简洁的解释问题，那么面试官就会怀疑你在工作时的表现是不是也会像你的谈话一样拖泥带水？可以先问问面试官，确定是否真的需要详细解释。

解释也是一门艺术，关键是确定重点，如果需要的话再深入到细节。当聊到业务的时候，就应该从业务的角度看问题，不要涉及任何技术术语。学会用简洁明了的方式解释问题。如果你能时刻把握主旨，那么这一点也不是问题。

＃3回答不出一些必知的基本技术问题

面试不是技术竞赛，不是看谁答对的问题多，但是有一些“必须知道”的核心Java和Web基础知识，你不能不知。例如，对于Java开发人员

1）不知道“==”和equals之间的区别。

2）不知道equals和hashCode方法被隐式调用时的约定。

3）不知道OO的概念和设计原则。

4）不能很好地处理多线程。

5）不知道如何在HTTP客户端与服务器端之间保持状态。

6）不能解释曾投入精力过的应用程序的高层体系结构。

7）不知道SQL。

…

＃4既写不好简单的代码，又回答不出如何解决棘手的问题

作为一个开发人员，你应该根据自己的经验水平，来针对给定的问题和情况编写代码。特别是如果碰到一个比较棘手的问题，那么即使你还没有解决方案，也应该将你的思路讲给面试官听。当然这在面试时会让人特别紧张，尤其是在还有时间限制的情况下，但是你也必须保持冷静，至少应该说明你将如何试着去解决问题的方法。

＃5糟糕的礼仪和态度

迟到，不适宜的着装，抖手抖脚，没有眼神接触，过于紧张，没有提问，显示不出对这份职业的兴趣，“我什么都知道”的高傲态度，贬低你的现在和以前的雇主，遇到技术问题时烦躁不安或者垂头丧气，为自己找理由而不是虚心接受错误，与面试官发生争执，不好的肢体语言，随波逐流而没有自己的看法，过于呆板，撒谎，嗓门太大，无法成为良好的倾听者，等等。

Java数据结构与算法

Thu, 26 Oct 2017 22:56:35 +0800

那么到底什么是数据结构和算法，数据结构算法又有什么用呢？

首先来说说什么是数据结构，直接上图

从图中我们可以很直观的看出数据结构涵盖的内容。

算法的介绍就相对抽象了，百度百科给出的解释是

算法是对特定问题求解步骤的一种描述，它是指令的有限序列，其中每一条指令表示一个或者多个操作。

但是我们从他的特性来理解就会简单多了。算法主要有五个特性

· 有穷性：指令序列是有限的

· 确定性：每条语句的含义明确，无二义性

· 可行性：每条语句都应在有限的时间内完成

· 输入：零个或者多个输入

· 输出：一个或者多个输出

说到数据结构算法的用处，当你用着java容器类很爽的时候，你有没有想过，怎么ArrayList像一个无限扩充的数组，也好像一个链表。好用吗？当然好用这就是数据结构的用处，只不过你在不知不觉中使用了。

用于现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还能方便地查询到所需要的数据吗。

Java打飞机小游戏（附完整源码)

Tue, 24 Oct 2017 22:56:12 +0800

写在前面

技术源于分享，所以今天抽空把自己之前用java做过的小游戏整理贴出来给大家参考学习。java确实不适合写桌面应用，这里只是通过这个游戏让大家理解oop面向对象编程的过程，纯属娱乐。代码写的很简单，也很容易理解，并且注释写的很清楚了，还有问题，自己私下去补课学习。

完整代码

敌飞机

分数奖励

蜜蜂

子弹类：是飞行物体

敌人的分数

飞行物(敌机，蜜蜂，子弹，英雄机)

英雄机

游戏启动主类

写在最后

深入解析Java垃圾回收机制

Mon, 23 Oct 2017 21:41:45 +0800

引入垃圾回收哪些内存需要回收？引用计数法可达性分析如何回收 Marking 标记 Normal Deletion 清除 Deletion with Compacting 压缩为什么需要分代收集？ JVM的分代新生代老年代永久代分代垃圾收集过程详述引入垃圾回收

JAVA

程序计数器、虚拟机栈、本地方法栈3个区域随线程而生，随线程而灭；栈中的栈帧随着方法的进入和退出而有条不紊地执行着出栈和入栈操作。每一个栈帧中分配多少内存基本上是在类结构确定下来时就已知的（尽管在运行期会由JIT编译器进行一些优化，但在本章基于概念模型的讨论中，大体上可以认为是编译期可知的），因此这几个区域的内存分配和回收都具备确定性，在这几个区域内就不需要过多考虑回收的问题，因为方法结束或者线程结束时，内存自然就跟随着回收了。而Java堆和方法区则不一样，一个接口中的多个实现类需要的内存可能不一样，一个方法中的多个分支需要的内存也可能不一样，我们只有在程序处于运行期间时才能知道会创建哪些对象，这部分内存的分配和回收都是动态的，垃圾收集器所关注的是这部分内存—–《深入理解Java虚拟机》自动垃圾回收机制就是寻找Java堆中的对象，并对对象进行分类判别，寻找出正在使用的对象和已经不会使用的对象，然后把那些不会使用的对象从堆上清除。自动垃圾回收机制就是要解决三个问题：

哪些内存需要回收？什么时候回收？如何回收？哪些内存需要回收？

引用计数法

对于第一个问题，也就是判断是否还需要使用，最简单的方法就是通过目前是否有引用指向这个对象，如果没有就说明这个对象不会再被使用了，如果有就说明这个对象可能还会继续被使用，这种通过引用是否存在的方法就叫做引用计数法，但这个方法存在一个问题就是无法解决对象循环引用的问题，因此又出现了可达性分析的方法来判断对象是否可以被会回收。

可达性分析

这个算法的基本思路就是通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。在Java语言中，可作为GC Roots的对象包括下面几种：

虚拟机栈（栈帧中的本地变量表）中引用的对象。方法区中类静态属性引用的对象。方法区中常量引用的对象。本地方法栈中JNI（即一般说的Native方法）引用的对象。如何回收

垃圾收集器通常会帮我们在后台自动进行垃圾回收。关于具体的回收过程只要有以下这些步骤

Step 1: Marking 标记第一步就是标记，也就是垃圾收集器会找出那些需要回收的对象所在的内存和不需要回收的对象所在的内存，并把它们标记出来，简单的说，也就是先找出垃圾在哪所有堆中的对象都会被扫描一遍，以此来确定回收的对象，所以这通常会是一个相对比较耗时的过程

Step 2: Normal Deletion 垃圾收集器会清除掉上一步标记出来的那些需要回收的对象区域

分享优秀Java程序员应有的编程风格

Sun, 22 Oct 2017 21:36:06 +0800

今天突发奇想，对编码习惯和编程风格很感兴趣，于是乎，找了一下关于编程风格（Java篇）的资料，希望对爱好编码或者开始学习编码的同学有帮助！

来自《The Elements of Java Style》-《Java编程风格》一书，值得一读的书籍，会让你在细节上节省很多时间，合作之间更加愉快！

好处不多说了，但是有几个原则如下：

1.保持原有风格

2.坚持最小惊奇原则

3.第一次就做对

4.记录所有非规范行为

格式规范：

1.缩进嵌套的代码：在每个代码块和嵌套中加入缩进，缩进代码，加强可读性。这些地方包括【类定义，内部类定义，方法定义，静态块，for循环语句，if-else语句，try、catch和finally块，匿名内部类，while语句，do-while语句】

2.断开很长的句子：第一，如果包含了逗号，那么在每一个逗号后面都另起一行，把逗号后面的每一个表达式都和逗号前面的表达式的第一个字母对齐。第二，应该在优先级最低的运算符之前断行。

3.使用空白：关键字和左括号之间，右括号和紧随其后的关键字，除了”.”之外的运算符与其前后的表达式之间用空格隔开。每个逻辑上独立的方法和代码段之间，定义类或者接口的成员之间，每个类和接口之间应该加入空白行。

4.不要直接使用Tab控制符：不同环境对Tab控制符的解释也是不同的。

命名约定：

1.名称应该具有实际意义

2.使用人们熟悉的名称

3.谨慎使用过长的名字，可以使用简明通用的缩写

4.尽量保留元音字母

5.缩写词的第一个字母大写

6.不要使用大小写来区分的名字

包命名：

1.用你所在组织的域名的倒序小写形式作为包的根限定词

2.使用单独的小写词作为每个包的根名

3.仅当新旧版本二进制兼容的时候，其包可以使用相同的名字，否则，请使用新名字

类型命名：

1.类和接口名中的每个单词的第一个字母大写

类命名：

1.用名词命名类

2.具有成组相关属性，静态服务或者常量的类名字使用复数形式

接口命名：

1.用名词或者形容词命名接口

方法命名：

1.方法名中的第一个单词小写，其后每个单词的第一个字母大写

2.用动词命名方法

3.遵循JavaBean中命名属性访问函数方法：set，get，is

变量命名：

1.变量命中的第一个单词小写，其后的每个单词的第一个字母大写

2.用名词命名变量

3.集合引用名要用复数形式

4.为不重要的临时变量简历并使用一套标准名字

字段命名：

1.使用this字段变量可以区分开局部变量

参数命名：

1.构造函数或者”set”方法给字段分配参数赋值，参数名应该和字段名相同

常量命名：

1.常量的每个单词均大写，单词之间使用下划线连接

文档约定：

1.为使用和维护你的代码的人编写文档

2.注释和代码要同步

3.使用积极的语气，省略无用的词语

注释类型：

1.用文档注释来描述编程接口

2.用标准注释格式隐藏代码而不必删除它们

3.用单行注释解释实现细节

文档注释：

1.在编写代码前描述编程接口

2.为公用，受保护，包，私有成员建立文档

3.为每个包编写总结和概述

4.为包的每个应用程序或组编写概述

注释风格：

1.对所有文档注释使用统一的格式和组织结构

2.关键字，标识符和常量应放到…标签中

3.将代码放入

…标签中

4.在标识符第一次出现的时候用{@link}标签

5.为Javadoc标签简历并使用一套固定的顺序

6.使用第三人称叙述的形式

Java集合面试问题和答案

Fri, 20 Oct 2017 20:19:28 +0800

1.Java集合框架是什么？说出一些集合框架的优点？

2.集合框架中的泛型有什么优点？

3.Java集合框架的基础接口有哪些？

4.为何Collection不从Cloneable和Serializable接口继承？

5.为何Map接口不继承Collection接口？

Java字符串的10大热点问题盘点

Wed, 18 Oct 2017 20:04:33 +0800

下面我为大家总结了10条Java开发者经常会提的关于Java字符串的问题，如果你也是Java初学者，仔细看看吧：

1、如何比较字符串，应该用”==”还是equals()？

总的来说，”==”是用来比较字符串的引用地址，而equals()才是比较字符串的值。两个值相同的字符串用”==”比较结果有可能是false，而用equals()则一定为true。除非两个字符串是同一个new出来的对象，不然比较字符串值是否相同应该要用equals()。

2、对那些安全敏感的信息，为什么用char[]存储要优于String？

String是不可变的，这就意味着它一旦被创建，就将永久驻留在内存中，直到垃圾回收器将其回收为止。然而用数组存储方式，你可以明确地改变数组中的元素，因此用数组方式，安全信息将有可能不存在系统内存的任何地方。

3、能否用字符串来声明switch语句？

JAVA 7及以后的版本是支持的。在JDK 7中，允许你使用字符串做switch语句的比较条件。jdk 6以前的版本，不能这样使用：

// java 7 only!switch (str.toLowerCase()) {      case "a":           value = 1;           break;      case "b":           value = 2;           break;
}

4、如何将字符串转换成数字int类型？

int n = Integer.parseInt("10");

很简单，但却会经常用到，也很容易被忽略。

5、如何用空格字符来分割字符串？

我们可以很方便地用正则表达式来分割字符串，”\s”表示空格字符，比如” “, “\t”, “\r”, “\n”

String[] strArray = aString.split("\\s+");

6、substring()方法究竟是什么？

在jdk 6中，substring()方法在原来字符串中提供了一个截取字符的窗口，它并没有创建一个新的String实例。如果你想创建新的字符数组，你可以在substring()后加一个空字符，就像这样：

str.substring(m, n) + ""

这样就会创建一个新的String实例，上面的方法有时候可以让你的程序运行速度更快，因为垃圾回收器可以将没用的大字符串回收走，并保留其子字符串。

7、String、StringBuilder和StringBuffer哪个更优？

String和StringBuilder：StringBuilder是可变的，也就是说用StringBuilder创建的字符串你可以随时改变它。StringBuilder和StringBuffer：StringBuffer是同步的，它是线程安全（thread-safe）的，但效率要比StringBuilder差得多。

8、如何重复输出字符串？

在Python中，我们只需要为字符串乘上一个数字就可以重复输出该字符串了。然而在Java中，我们可以用StringUtils的repeat()方法来实现，StringUtils是Apache公共语言库的其中一个类库成员。

String str = "abcd";String repeated = StringUtils.repeat(str,3);//abcdabcdabcd

9、如何将字符串转换成日期类型？

你可以按以下方法来做，代码如下：

String str = "Sep 17, 2013";Date date = new SimpleDateFormat("MMMM d, yy", Locale.ENGLISH).parse(str);
System.out.println(date);//Tue Sep 17 00:00:00 EDT 2013

10、如何统计指定字符在字符串中出现的频率

同样我们利用了Apache公共语言库中的StringUtils，代码如下：

int n = StringUtils.countMatches("11112222", "1");
System.out.println(n);

JVM 语言的兴衰史

Thu, 12 Oct 2017 23:38:25 +0800

不管什么时候，都会有一些预测 Java 覆灭的帖子出现。但有趣的是，这些帖子从不写预言成真的日期。说实话，它们说的都算正确，因为这是每一种语言的最终命运都是：覆灭湮没，准确地说是越来越少地被利用到新项目中。问题是：最后谁会取代它们呢？

上周我们在 InfoQ 一篇同样类型的文章。至少，这篇文章说出来这个语言可能的替代者 Kotlin。这让我对 JVM 的语言现状和趋势有了许多思考：注意，语言的趋势与每个语言的技术优点和缺点无关。

我于 2001 年年底开始做 Java 开发，当时，Java 是真的很酷。每一个新开发者都想使用所谓的新技术：无论是 .NET 还是 Java，而有经验一些的开发者使用的是 COBOL。我在学校学习了 C 和 C++，所以 Java 内存管理对于我来说非常简单。我对 Java 很满意，但并不是每个人都这么认为。

Groovy 诞生于 2003 年。但我不记得我是什么时候开始学习它的。而实际上：使用它后我不再需要一门脚本语言了。在具有多个开发团队并长时间开发企业级应用程序的背景之下，静态类型相比动态类型拥有巨大优势。尤其在进行产品测试以检查类型系统时。我唯一需要创建脚本的时候，是作为 WebSphere 管理员时：选择 Python 还是 TCL。

一年之后，Scala在2004年被我接受。我不记得是什么时候以及是怎样知道Scala的，但那时候确实是很晚了。与Groovy相反，我决定试试它。主要的理由是我长期以来对创建“更好”的代码（更好的可读性和可维护性）感兴趣。Scala是静态类型的，它更像我正在寻找的东西。我报了Coursera课程Scala中的函数式编程原理。它有三个主要的影响：

它让我质疑我写Java代码的方式。例如，为什么当我设计类时要自动生成getter和setter方法？

对大多数开发者来说，我觉得Scala很容易写出缺乏可读性的的代码——包括我。

我开始寻找其他替代语言。

在 Groovy 和 Scala 之后，第二代（如果你把 Java 也算做第一代的话，则是第三代）JVM 语言包括：

JetBrains Kotlin

Red Hat Ceylon

Eclipse eXtend

大致浏览一遍后，我确信他们没有太多的吸引力，不值得我投入时间。

几年前，我决定自学基本的 Android 开发，以便能够了解移动开发者的开发环境。好家伙，即使有多年开发 Java EE 和 Spring 应用程序的经验，但它还真给我一个惊喜了 - 还不是愉快的那种。这就像回到过去十年前那样的开发体验，Android API 非常低级，更别说在本地测试应用程序。经过快速的搜索相关信息，我发现 Kotlin 在很多地方被提到，所以最后决定试一试。我立即爱上 Kotlin 了，得亏它的扩展功能，我可以将现有的垃圾 API 改进得更好，甚至更优雅。我开始更多的挖掘这门语言，并开始在服务器端项目中使用 Kotlin。然后，Spring 框架宣布了与 Kotlin 的整合。然后在 Google I/O 大会上，Google 也宣布在 Android 开发中官方支持 Kotlin。

死磕 Java 并发：Java 内存模型之 happens-before

Tue, 10 Oct 2017 22:10:06 +0800

那么我们正确使用同步、锁的情况下，线程A修改了变量a何时对线程B可见？

我们无法就所有场景来规定某个线程修改的变量何时对其他线程可见，但是我们可以指定某些规则，这规则就是happens-before，从JDK 5 开始，JMM就使用happens-before的概念来阐述多线程之间的内存可见性。

在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。

happens-before原则非常重要，它是判断数据是否存在竞争、线程是否安全的主要依据，依靠这个原则，我们解决在并发环境下两操作之间是否可能存在冲突的所有问题。下面我们就一个简单的例子稍微了解下happens-before ；

i = 1; //线程A执行

j = i ; //线程B执行

j 是否等于1呢？假定线程A的操作（i = 1）happens-before线程B的操作（j = i）,那么可以确定线程B执行后j = 1 一定成立，如果他们不存在happens-before原则，那么j = 1 不一定成立。这就是happens-before原则的威力。

happens-before原则定义如下：

如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。

两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。

下面是happens-before原则规则：

程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；

锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；

volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；

传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；

线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；

线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；

线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；

对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

我们来详细看看上面每条规则（摘自《深入理解Java虚拟机第12章》）：

程序次序规则：一段代码在单线程中执行的结果是有序的。注意是执行结果，因为虚拟机、处理器会对指令进行重排序（重排序后面会详细介绍）。虽然重排序了，但是并不会影响程序的执行结果，所以程序最终执行的结果与顺序执行的结果是一致的。故而这个规则只对单线程有效，在多线程环境下无法保证正确性。

锁定规则：这个规则比较好理解，无论是在单线程环境还是多线程环境，一个锁处于被锁定状态，那么必须先执行unlock操作后面才能进行lock操作。

volatile变量规则：这是一条比较重要的规则，它标志着volatile保证了线程可见性。通俗点讲就是如果一个线程先去写一个volatile变量，然后一个线程去读这个变量，那么这个写操作一定是happens-before读操作的。

传递规则：提现了happens-before原则具有传递性，即A happens-before B , B happens-before C，那么A happens-before C

Java知识点归纳-J2EE 、 Web 部分

Mon, 09 Oct 2017 22:07:37 +0800

J2EE（Java2 Enterprise Edition）刚出现时一般会用于开发企业内部的应用系统，特别是web应用，所以渐渐，有些人就会把J2EE和web模式画上了等号。但是其实 J2EE 里面并不仅仅是web，可以看到很多其中的规范都是通用的，目的是为了高效开发出健壮的服务企业业务模式的应用系统。J2EE中也是可以没有web界面的应用，而现在面向大众用户开发的网站往往也会使用到很多的J2EE的技术，所以J2EE和web开发的概念都是融合在了一起了。

笔者在JAVA开发刚入行的时候，也是做了不少web相关的项目，之后渐渐地web使用比较少了，现在web开发的技术日新月异，不过一些基础知识还是类似，所以也把这部分内容稍作整理，以期望可以给大家一些经验。

这次主要涉及到的两大块内容: Web相关的， J2EE相关的技术

Web部分:

脱离开各种语言，纯粹和 web相关的就是这些: HTML，CSS，JavaScript。哪怕你不用Java开发，用C#、PHP或者Python，这些内容都是通用，这里主要偏重一些基础知识。

HTTP协议，HTTPS协议

我觉得做Web开发，HTTP是基础中的基础。在一开始的时候，开发者可能对于这个内容了解不是非常深入，只是有个初步的概念，这个没有问题，可以先从了解，简单使用开始。不过一旦有了一些web开发经验之后，你就需要把这块内容深入理解吃透。只知道简单概念，没有深入了解，可能并不会影响你开始上手做web开发，但是一旦涉及到一些性能调优、系统架构等工作，就需要你对HTTP有一个深入的了解，才能把工作做好。

对于HTTP请求，我主要会关注以下内容:

HTTP请求的模式: request/response

HTTP请求的方法：GET， POST， PUT，DELETE 等等

协议的具体格式: head + body

协议的各类返回码:1XX，2XX，3XX，4XX，5XX

Header中一些主要属性的含义和使用场景

HTTPS协议

Cookie的基本原理和使用场景

HTML， CSS

这是WEB开发的一个基础，如果公司有专门的前端开发人员，可能你就不需要做这块相关的内容。可能只需要准备一些服务，可以提供一些数据就行。不过要是公司没有专门的前端人员，那就需要你自己写简单的页面和简单的布局了。这种情况下，还是对HTML和CSS必须有个简单的了解才行。

HTML简单了解的话需要知道页面的结构，具体各个表单，标签的使用方法，CSS需要知道一些基本的选择器的编写和使用。但这也只能满足一些简单页面的要求。如果有更加复杂页面的开发需求，那对CSS+DIV的使用需要有更加深入的了解了，具体内容因为自己对这方面涉及不多，也不多说了，大家可以再找其他的参考资料。

JavaScript：

前端开发的语言，唯一的语言，就是JS。并且从中衍生出一个很优秀的框架jQuery。现在前端基本上只要有一点复杂度的，都会使用这两种技术。并且以jquery为基础，还有一些其他前台框架，提供了各种动态效果，还有表格，表单等一些常用的处理。近两年，AngularJS框架又开始火热起来，这个框架在前端实现了MVC的架构，给前端的开发带来了革命性的影响(但是不意味着所有的前端开发都应该要用这个)。这些都是很值得好好看一下。即便不是专攻前端开发的，但是对于这几个技术点，能够先了解一下基本情况，基本的原理，对于web开发来说，还是大有好处的。

Webservice

在现在的企业应用开发中，Webservice已经是个必备的工具了。在各个企业中，经过一段时间积累，会有很多不同种类的应用，这些应用可能都会使用不同的语言开发，并且需要相互之间的通讯。通讯的首选就是Webservice。前后台的交互，服务之间的交互，或者不同语言之间的交互，都可以使用Webservice这个技术。

Webservice的实现方式多种多样，两者共同点是大家都是以HTTP协议为基础的，都可以跨域，跨语言进行访问。

用的比较多的，一个是SOAP协议的方式。这是比较传统的webservice 的实现，这个协议比较重量级，发布者会将webservice以wsdl形式发布，调用者通过wsdl可以直接生成实体类等。对于调用者来说，“调用”这个步骤会更容易处理一些。不过SOAP形式也存在着消息量大，传输效率低等缺陷。SOAP协议本身的可选项比较多，比较复杂，各个属性设置略有差异会导致服务通讯的失败，需要在调试中需要花费更多的时间。

现在更加流行的是使用RESTFUL的Webservice。这种技术是简化了URL，或者说对URL做了一定格式的限定，同时配合上HTTP的各种method，包括有GET，POST，DELTE，PUT 等，来实现整体service的各种功能。一般传输的内容都是json格式的字符串。Restful的Webservice的优点在于这是一种更加轻量级的使用方式，传输效率更高，接口约定更加清晰，双方调试也会更加便利一些。缺点在于，json格式太灵活，所以双方都需要自行处理json中的各个参数。对于接口实体类的处理需要更多的逻辑和代码。

J2EE部分

JDBC(可以在J2SE中使用)

JDBC用于java和数据库交互。它是Java面向接口编程的一个典型实例：开发者使用JDBC的API进行开发，但是底层可以针对不同的数据库使用不同的JDBC驱动(由各个数据库供应商提供)。JDBC被归为了J2EE的规范中，但是在一般的java程序中也可以使用，而且也是几乎都会被直接或者间接使用（除非不用数据库）。这从侧面也说明了，其实J2EE企业开发和web开发并不是同一个概念，而是相互融合的。

JDBC是Java中最原始，最纯粹，效率最高的访问数据库的方式，我们熟知的hibernate、 Mybatis等ORM框架都是在JDBC基础上做的封装。了解JDBC对于以后和数据库更好打交道会有着很大的用处。哪怕是一个java开发新手，你需要去学习Hibernate、Mybatis等框架，你也需要先学习JDBC作为这些的基础。

对于JDBC的具体怎么实现，这个真不需要了解到那么深入。我推荐大家学习JDBC至少需要掌握以下内容：

1.JDBC的原理: JDBC为接口，可以有不同的驱动driver类

2.JDBC中的一些基本概念: connection， statement， resultset 等

3.JDBC使用的基本流程

Java总结篇系列：Java泛型

Sun, 08 Oct 2017 20:14:45 +0800

首先，我们看下下面这段简短的代码:

public class GenericTest { public static void main(String[] args) {

List list = new ArrayList();

list.add("qqyumidi");

list.add("corn");

list.add(100); for (int i = 0; i < list.size(); i++) {

String name = (String) list.get(i); // 1

System.out.println("name:" + name);

}

Java 中的异常和处理详解

Tue, 03 Oct 2017 19:16:17 +0800

简介

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。异常发生时，是任程序自生自灭，立刻退出终止，还是输出错误给用户？或者用C语言风格：用函数返回值作为执行状态？。

Java提供了更加优秀的解决办法：异常处理机制。

异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。

Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw 语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。

Throwable类是Java异常类型的顶层父类，一个对象只有是 Throwable 类的（直接或者间接）实例，他才是一个异常对象，才能被异常处理机制识别。JDK中内建了一些常用的异常类，我们也可以自定义异常。

Java异常的分类和类结构图

Java标准裤内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

总体上我们根据Javac对异常的处理要求，将异常类分为2类。

非检查异常（unckecked exception）：Error 和 RuntimeException 以及他们的子类。javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常。所以如果愿意，我们可以编写代码处理（使用try…catch…finally）这样的异常，也可以不处理。对于这些异常，我们应该修正代码，而不是去通过异常处理器处理。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException，错误的强制类型转换错误ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。

检查异常（checked exception）：除了Error 和 RuntimeException的其它异常。javac强制要求程序员为这样的异常做预备处理工作（使用try…catch…finally或者throws）。在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过。这样的异常一般是由程序的运行环境导致的。因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，于是程序员就应该为这样的异常时刻准备着。如SQLException , IOException,ClassNotFoundException 等。

需要明确的是：检查和非检查是对于javac来说的，这样就很好理解和区分了。

初识异常

下面的代码会演示2个异常类型：ArithmeticException 和 InputMismatchException。前者由于整数除0引发，后者是输入的数据不能被转换为int类型引发。

package com.example;
import java. util .Scanner ;
public class AllDemo
{
public static void main (String [] args )

Java序列化的几种方式以及序列化的作用

Mon, 02 Oct 2017 20:40:10 +0800

一.Java序列化的作用

有的时候我们想要把一个Java对象变成字节流的形式传出去，有的时候我们想要从一个字节流中恢复一个Java对象。例如，有的时候我们想要

把一个Java对象写入到硬盘或者传输到网路上面的其它计算机，这时我们就需要自己去通过java把相应的对象写成转换成字节流。对于这种通用

的操作，我们为什么不使用统一的格式呢？没错，这里就出现了java的序列化的概念。在Java的OutputStream类下面的子类ObjectOutput-

Stream类就有对应的WriteObject(Object object) 其中要求对应的object实现了java的序列化的接口。

为了更好的理解java序列化的应用，我举两个自己在开发项目中遇到的例子:

1)在使用tomcat开发JavaEE相关项目的时候，我们关闭tomcat后，相应的session中的对象就存储在了硬盘上，如果我们想要在tomcat重启的

时候能够从tomcat上面读取对应session中的内容，那么保存在session中的内容就必须实现相关的序列化操作。

2)如果我们使用的java对象要在分布式中使用或者在rmi远程调用的网络中使用的话，那么相关的对象必须实现java序列化接口。

亲爱的小伙伴，大概你已经了解了java序列化相关的作用，接下来们来看看如何实现java的序列化吧。~

二.实现java对象的序列化和反序列化。

Java对象的序列化有两种方式。

a.是相应的对象实现了序列化接口Serializable，这个使用的比较多，对于序列化接口Serializable接口是一个空的接口，它的主要作用就是

标识这个对象时可序列化的，jre对象在传输对象的时候会进行相关的封装。这里就不做过多的介绍了。

下面是一个实现序列化接口的Java序列化的例子:非常简单

package com.shop.domain;import java.util.Date;public class Article implements java.io.Serializable {    private static final long serialVersionUID = 1L;    private Integer id;     private String title;  //文章标题    private String content;  // 文章内容    private String faceIcon;//表情图标    private Date postTime; //文章发表的时间    private String ipAddr;  //用户的ip    private User author;  //回复的用户    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getTitle() {        return title;    }    public void setTitle(String title) {        this.title = title;    }    public String getContent() {        return content;    }    public void setContent(String content) {        this.content = content;    }    public String getFaceIcon() {        return faceIcon;    }    public void setFaceIcon(String faceIcon) {        this.faceIcon = faceIcon;    }    public Date getPostTime() {        return postTime;    }    public void setPostTime(Date postTime) {        this.postTime = postTime;    }    public User getAuthor() {        return author;    }    public void setAuthor(User author) {        this.author = author;    }    public String getIpAddr() {        return ipAddr;    }    public void setIpAddr(String ipAddr) {        this.ipAddr = ipAddr;    }}

b.实现序列化的第二种方式为实现接口Externalizable，Externlizable的部分源代码如下:

开发人员需要掌握的英文词汇，必须要学会的

Wed, 27 Sep 2017 11:59:42 +0800

当年学习Java时想过，英语不好或者一窍不通，能不能学好Java开发；就这个问题请教了开发前辈，答案是不懂英文也可以学好Java，但必须要学会一些常用英文词汇，必竟Java是英文开发创造的，以下整理了开发中常用的词汇及中文含义；当然知道这些远远不够，我们可以在学习工作过程中慢慢积累，渐渐会发现原来学会了这么多英文，好了，开始学习吧

我以英文首字母进行排序：

1、Abstract class 抽象类:抽象类是不允许实例化的类，因此一般它需要被进行扩展继承。

2、Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。

3、Anonymous class 匿名类:当你需要创建和使用一个类，而又不需要给出它的名字或者再次使用的使用，就可以利用匿

名类。

4、Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。

5、API 应用程序接口:提供特定功能的一组相关的类和方法的集合。

6、Array 数组:存储一个或者多个相同数据类型的数据结构，使用下标来访问。在Java中作为对象处理。

7、Base class 基类:即被扩展继承的类。

8、Call stack 调用堆栈:调用堆栈是一个方法列表，按调用顺序保存所有在运行期被调用的方法。

9、Casting 类型转换 :即一个类型到另一个类型的转换，可以是基本数据类型的转换，也可以是对象类型的转换。

10、Char 字符:容纳单字符的一种基本数据类型。

11、Child class 子类:见继承类Derived class

12、Class 类:面向对象中的最基本、最重要的定义类型。

13、Class members 类成员:定义在类一级的变量，包括实例变量和静态变量。

14、Class methods 类方法:类方法通常是指的静态方法，即不需要实例化类就可以直接访问使用的方法。

15、Class variable 类变量:见静态变量Static variable

16、Collection 容器类:容器类可以看作是一种可以储存其他对象的对象，常见的容器类有Hashtables和Vectors。

17、Collection interface 容器类接口:容器类接口定义了一个对所有容器类的公共接口。

java邮件类---MailUtils 用户网站统一发送激活码

Mon, 25 Sep 2017 20:52:08 +0800

package cn.pyd.itcaststore.utils;

import java.net.Authenticator;
import java.net.PasswordAuthentication;
import java.util.Properties;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMessage.RecipientType;

public class MailUtils {
	public static void sendMail(String email,String emailMsg) throws AddressException,MessagingException{
		//1.创建Properties对象，并设置邮件服务器的基本信息
		Properties props=new Properties();
		//1.1设计邮件传输协议为SMIP
		 props.put("mail.smtp.host", "smtp.163.com");//存储发送邮件服务器的信息 
	 props.put("mail.smtp.auth", "true");//同时通过验证
	 props.setProperty("mail.transport.protocol", "smtp"); 
		//1.4创建验证器
		javax.mail.Authenticator auth=new javax.mail.Authenticator() {
			public javax.mail.PasswordAuthentication getPasswordAuthentication() {
				return new javax.mail.PasswordAuthentication("用户名", "密码");
			}
		};
		//实例化邮件会话Session
		Session session=Session.getInstance(props, auth);
		//2.创建一个Message，该对象相当于邮件内容
		Message message=new MimeMessage(session);
		//2.1设置发送者
		message.setFrom(new InternetAddress("用户名@163.com"));
		//2.2设置发送方式与接受者，邮件接受者在调用sendMail()方法时通过参数传递过来
		message.setRecipient(RecipientType.TO,new InternetAddress(email));
		//2.3设置邮件发送主题
		message.setSubject("用户激活");
		message.setContent(emailMsg, "text/html;charset=utf-8");
		//3.发送邮件
		Transport.send(message);
	}
}

学习Java需吃透这些基本概念你知道吗？

Sun, 24 Sep 2017 21:14:30 +0800

学习好比盖房子，打地基好很重要，房了能盖多高关键看地基；学习同样道理，基础知识是以后学习一切技术的必要条件，我们在准备学习一门开发语言时，首先要学习它的基础，不仅要会，更要融会贯通；万变不离其宗，无论技术框架怎么变，本质都是对基础的封装再造。

在以往的工作学习中，我总结了一些Java非常重要的知识点或者说基本概念，好了，进入正题：

1、面向对象编程（OOP）:OOP最重要的思想是类,类是模板,从类中构造一个对象,即创建了这个类的一个实例；

2、封装:是把数据和行为结合在一起，并对对象使用者隐藏数据的实现过程,通常一个对象中的数据叫他的实例字段(instance field) ；

3、继承:Java中允许在已经存在的类的基础上构建新的类,当你继承一个已经存在的类时,那么你就复用了这个类的方法和字段,同时你可以在新类中添加新的方法和字段；

4、多态:在java中,对象变量是多态的；需要注意的是java中不支持多重继承；

5、类之间的关系:

use-a :依赖关系；

has-a :聚合关系；

is-a : 继承关系–例:A类继承了B类,此时A类不仅有了B类的方法,还有其自己的方法；

6、构造对象使用构造器:构造器是一种特殊的方法,它的作用是构造对象并对其初始化，

构造器特点:构造器可以有0个,一个或多个参数；

构造器和类名称是相同的；

一个类可以有多个构造器；

构造器没有返回值；

构造器一定是和new运算符一起使用的；

7、包(package)：Java允许把一个或多个类放在一起成为一组,称作为包,以便于更好的管理,标准Java库分为许多包如java.lang、java.util、java,net等,包是分层次的，所有的java包都在java和javax包层次内；

8、重载:当多个方法具有相同的名字而含有不同的参数时,这时就发生了重载，编译器会选出调用哪个方法；

9、健壮特性:Java采取了一个安全指针模型,能有效防止重写内存和数据崩溃；

10、安全:Java可以用来构建防病毒和防攻击的系统，事实证明Java在防毒方面做的比较好；

11、可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定，所以有很好的可移植性；

12、多线程:由于Java的机制，它处理多线程的过程很简单,Java把多线程实现交给底下操作系统或线程程序完成，所以多线程是Java作为服务器端开发语言的流行原因之一；

13、动态绑定:这是Java调用对象方法的机制；

14、Java中的每一个类都是从Object类扩展而来的；

15、内部类:一个内部类的定义是定义在另一个内部类中；

以上只列出了比较重要的，必须掌握的知识点。

书城注册登录servlet--UserService.java

Sat, 23 Sep 2017 21:03:03 +0800

package cn.itcast.itcaststore.service;
import java.sql.SQLException;
import java.util.Date;
import javax.security.auth.login.LoginException;
import cn.itcast.itcaststore.dao.UserDao;
import cn.itcast.itcaststore.domain.User;
import cn.itcast.itcaststore.exception.ActiveUserException;
import cn.itcast.itcaststore.exception.RegisterException;
import cn.itcast.itcaststore.utils.MailUtils;

public class UserService {
	private UserDao dao = new UserDao();
	// 注册操作
	public void register(User user) throws RegisterException {
		// 调用dao完成注册操作
		try {
			dao.addUser(user);
			// 发送激活邮件
			String emailMsg = "感谢您注册网上书城，点击"
					+ " 激活 后使用。"
							+ "
为保障您的账户安全，请在24小时内完成激活操作";
			MailUtils.sendMail(user.getEmail(), emailMsg);
		} catch (Exception e) {
			e.printStackTrace();
			throw new RegisterException("注冊失败");
		}
	}
	// 激活用户
	public void activeUser(String activeCode) throws ActiveUserException {
		try {
			// 根据激活码查找用户
			User user = dao.findUserByActiveCode(activeCode);
			if (user == null) {
				throw new ActiveUserException("激活用户失败");
			}
			// 判断激活码是否过期 24小时内激活有效.
			// 1.得到注册时间
			Date registTime = user.getRegistTime();
			// 2.判断是否超时
			long time = System.currentTimeMillis() - registTime.getTime();
			if (time / 1000 / 60 / 60 > 24) {
				throw new ActiveUserException("激活码过期");
			}
			// 激活用户，就是修改用户的state状态
			dao.activeUser(activeCode);
		} catch (SQLException e) {
			e.printStackTrace();
			throw new ActiveUserException("激活用户失败");
		}
	}
	// 登录操作
	public User login(String username, String password) throws LoginException {
		try {
			//根据登录时表单输入的用户名和密码，查找用户
			User user = dao.findUserByUsernameAndPassword(username, password);
			//如果找到，还需要确定用户是否为激活用户
			if (user != null) {
				// 只有是激活才能登录成功，否则提示“用户未激活”
				if (user.getState() == 1) {
					return user;
				}
				throw new LoginException("用户未激活");
			}
			throw new LoginException("用户名或密码错误");
		} catch (SQLException e) {
			e.printStackTrace();
			throw new LoginException("登录失败");
		}
	}
}

Java验证码的绘制

Fri, 22 Sep 2017 20:08:32 +0800

package cn.itcast.itcaststore.utils;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * 生成验证码的工具类
 */
public class CheckImageServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	// 集合中保存所有成语
	private List words = new ArrayList();
	@Override
	public void init() throws ServletException {
		// 初始化阶段，读取new_words.txt
		// web工程中读取文件，必须使用绝对磁盘路径
		String path = getServletContext().getRealPath("/WEB-INF/new_words.txt");
		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					new FileInputStream(path), "utf-8"));
			String line;
			while ((line = reader.readLine()) != null) {
				words.add(line);
			}
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// 禁止缓存
		// response.setHeader("Cache-Control", "no-cache");
		// response.setHeader("Pragma", "no-cache");
		// response.setDateHeader("Expires", -1);
		int width = 180;
		int height = 30;
		// 步骤一 绘制一张内存中图片
		BufferedImage bufferedImage = new BufferedImage(width, height,
				BufferedImage.TYPE_INT_RGB);
		// 步骤二 图片绘制背景颜色 ---通过绘图对象
		Graphics graphics = bufferedImage.getGraphics();// 得到画图对象 --- 画笔
		// 绘制任何图形之前 都必须指定一个颜色
		graphics.setColor(getRandColor(200, 250));
		graphics.fillRect(0, 0, width, height);
		// 步骤三 绘制边框
		graphics.setColor(Color.WHITE);
		graphics.drawRect(0, 0, width - 1, height - 1);
		// 步骤四 四个随机数字
		Graphics2D graphics2d = (Graphics2D) graphics;
		// 设置输出字体
		graphics2d.setFont(new Font("宋体", Font.BOLD, 18));
		Random random = new Random();// 生成随机数
		int index = random.nextInt(words.size());
		String word = words.get(index-1);// 获得成语
		// 定义x坐标
		int x = 10;
		for (int i = 0; i < word.length(); i++) {
			// 随机颜色
			graphics2d.setColor(new Color(20 + random.nextInt(110), 20 + random
					.nextInt(110), 20 + random.nextInt(110)));
			// 旋转 -30 --- 30度
			int jiaodu = random.nextInt(60) - 30;
			// 换算弧度
			double theta = jiaodu * Math.PI / 180;
			// 获得字母数字
			char c = word.charAt(i);
			// 将c 输出到图片
			graphics2d.rotate(theta, x, 20);
			graphics2d.drawString(String.valueOf(c), x, 20);
			graphics2d.rotate(-theta, x, 20);
			x += 40;
		}
		// 将验证码内容保存session
		request.getSession().setAttribute("checkcode_session", word);
		// 步骤五 绘制干扰线
		graphics.setColor(getRandColor(160, 200));
		int x1;
		int x2;
		int y1;
		int y2;
		for (int i = 0; i < 30; i++) {
			x1 = random.nextInt(width);
			x2 = random.nextInt(12);
			y1 = random.nextInt(height);
			y2 = random.nextInt(12);
			graphics.drawLine(x1, y1, x1 + x2, x2 + y2);
		}
		// 将上面图片输出到浏览器 ImageIO
		graphics.dispose();// 释放资源
		ImageIO.write(bufferedImage, "jpg", response.getOutputStream());
	}
	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}
	/**
	 * 取其某一范围的color
	 * @param fc int 范围参数1
	 * @param bc int 范围参数2
	 * @return Color
	 */
	private Color getRandColor(int fc, int bc) {
		// 取其随机颜色
		Random random = new Random();
		if (fc > 255) {
			fc = 255;
		}
		if (bc > 255) {
			bc = 255;
		}
		int r = fc + random.nextInt(bc - fc);
		int g = fc + random.nextInt(bc - fc);
		int b = fc + random.nextInt(bc - fc);
		return new Color(r, g, b);
	}
}

Java-Filter过滤器用于过滤整个项目的编码

Fri, 22 Sep 2017 20:00:54 +0800

整个分为实现类以及在web.xml文件中对编写的filter类进行注册

package cn.itcast.itcaststore.web.filter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
/**
 * 编码过滤器（用于统一项目编码）
 */
public class EncodingFilter implements Filter {
	public void init(FilterConfig filterConfig) throws ServletException {
}
public void doFilter(ServletRequest request, ServletResponse response,
		FilterChain chain) throws IOException, ServletException {
	// 处理请求乱码
	HttpServletRequest httpServletRequest = (HttpServletRequest) request;
	HttpServletRequest myRequest = new MyRequest(httpServletRequest);
	// 处理响应乱码
	response.setContentType("text/html;charset=utf-8");
	chain.doFilter(myRequest, response);
}
public void destroy() {

}

}
// 自定义request对象
class MyRequest extends HttpServletRequestWrapper {
private HttpServletRequest request;
private boolean hasEncode;
public MyRequest(HttpServletRequest request) {
super(request);// super必须写
this.request = request;
}
// 对需要增强方法 进行覆盖
@SuppressWarnings({ “unchecked”, “rawtypes” })
@Override
public Map getParameterMap() {
// 先获得请求方式
String method = request.getMethod();
if (method.equalsIgnoreCase(“post”)) {
// post请求
try {
// 处理post乱码
request.setCharacterEncoding(“utf-8”);
return request.getParameterMap();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
} else if (method.equalsIgnoreCase(“get”)) {
// get请求
Map<string, string[]=""> parameterMap = request.getParameterMap();
if (!hasEncode) { // 确保get手动编码逻辑只运行一次
for (String parameterName : parameterMap.keySet()) {
String[] values = parameterMap.get(parameterName);
if (values != null) {
for (int i = 0; i < values.length; i++) {
try {
values[i] = new String(values[i].getBytes(“ISO-8859-1”),“utf-8”);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
}
hasEncode = true;
}
return parameterMap;
}
return super.getParameterMap();
}
@Override
public String getParameter(String name) {
@SuppressWarnings(“unchecked”)
Map<string, string[]=""> parameterMap = getParameterMap();
String[] values = parameterMap.get(name);
if (values == null) {
return null;
}
return values[0]; // 取回参数的第一个值
}
@Override
public String[] getParameterValues(String name) {
@SuppressWarnings(“unchecked”)
Map<string, string[]=""> parameterMap = getParameterMap();
String[] values = parameterMap.get(name);
return values;
}
}
</string,></string,></string,>

web.xml配置

Java项目实战经验—程序员成长的钥匙

Thu, 21 Sep 2017 22:23:27 +0800

Java就是用来做项目的！Java的主要应用领域就是企业级的项目开发！要想从事企业级的项目开发，你必须掌握如下要点：

1、掌握项目开发的基本步骤

2、具备极强的面向对象的分析与设计技巧

3、掌握用例驱动、以架构为核心的主流开发方法

没有人愿意自己一辈子就满足于掌握了一些代码实现的技巧，别人告诉你要实现什么，你就用代码堆砌来实现别人的要求！你必须学会从整个项目的角度去思考！你必须学会假如你是项目经理，你该如何思考！你必须学会假如你是架构师，你该如何思考！你必须掌握针对某个特定问题领域的分析方法！

关于基础知识：你可以看看这些名词或知识点，看是否能说出个一二三四来。

JavaSE

----基本语法、数据类型、操作符等：int、long、Integer、Long、if、else、for、while

----面向对象：class（类）、Object（对象）、instance（实例）、state（状态）、behavior（行为）、field、method、new、可见性（访问控制）、attribute、property、package、import、static variable、class variable、instance variable、heap、method area、stack、GC（垃圾回收）、override、overload、对象转型(casting)、多态、this、super

----异常处理：理解编译期错误和运行期错误的区别、Exception、RuntimeException、checked exception、unchecked exception、try、catch、finally、throw new XXXException、throws XXXException、异常处理的基本原则

----数组与集合：数组的定义和使用方法、Collection、List、Set、Map、ArrayList、HashSet、HashMap、Iterator、equals、hashCode、Comparable、Comparator

----常用类：String、intern、常量池、StringBuffer、java.util.Date、SimpleDateFormat、Regex（正则表达式）

----反射机制：Class、Method、Field、invoke、newInstance、BeanUtils（apache-commons）、PropertyUtils（apache-commons）

----输入输出流：InputStream、OutputStream、Reader、Writer、Adapter设计模式与原始流类、Decorator设计模式与包装流类、对象序列化和反序列化

----多线程：Thread、Runnable、sleep、wait、notify、synchronized、lock

Servlet和JSP

----HttpServlet、doGet、doPost、HttpServletRequest、HttpServletResponse、request.getParameter()、request.setAttribute()、request.getAttribute()、request.getSession()、ServletContext、Filter、web.xml、tomcat、forward与redirect、http协议的无状态性、cookie、JSP Scope Object、<c:out …/>、<c:forEach …>

HTML与JavaScript

----你需要能够理解常见的网页标签、理解在网页中引入JavaScript的方法、以及JavaScript的基本语法与使用方法

以上，就是你进一步学习Java所必备的基本知识。特别是一些个专业术语和名词，看到这些名词，如果你像看到亲爹一样亲切，那么说明你对Java的基础知识就很熟悉了。

接下来是SSH：

对于初学者来说，这三大框架被赋予了太多神秘的色彩，似乎它们是重中之重的知识！但是对于拥有多年Java开发经验的专业技术人员来说，对于那些Java牛人来说，却对这三大框架不太感冒！难道它们不重要吗？

现在很多企业都在用这三大框架，所以很多企业也把掌握这三大框架作为招聘的必备条件。不可否认的是，也有很多大型企业没有用这三大框架，这些企业经过多年发展，自身已经有一定的技术积累，也形成了自己独特的技术框架体系。这三大框架既可以说很重要，也可以说不重要。

说重要的原因在于：这三大框架对JavaEE开发中所存在的普遍的问题，提供了优美的解决方案，它们蕴含了这个行业中最NB的开发人员的努力和想法，所以，学习这三大框架，你就可以窥探到这些处于技术巅峰的牛人们究竟对一个问题是怎么想的，通过一种什么样的设计思路去解决问题的。所以，对于你来说，你没有太多项目开发的经验，经验是什么？经验就是你知道可能会遇到哪些问题，针对哪个问题可以有哪些解决方法，在某个情景下，哪种解决方法是较好的，哪种方法不太好等等！如果你没做过什么项目，你根本就不会去意识到你可能会遇到哪些问题，而这些问题往往又是非常关键的！解决得不好，会影响到你的程序的稳定性、可扩展性等等！三大框架就给初学者提供了了解你以后可能会遇到哪些问题，以及针对这些问题的解决方案！

当你了解了这三大框架为什么是重要的，那么你也就能理解，为什么这三大框架也可以说是不重要的。如果你曾经开发过很多项目，你碰到了各种各样的问题，凭着你的技术功底，逐个击破了这些问题，在这些人眼里，三大框架（是不是还有N个框架？呵呵）都是浮云！

你属于哪一种人呢？如果你没有太多项目开发经验，那么三大框架对于你来说就是非常重要的！而且，由此你也知道了该怎么去学这三大框架。对于三大框架的学习而言，着力点在于给你展示问题，并触发你自己主动的思考，我们鼓励你提出自己的想法，也许你的想法很白痴，但那毕竟是你自己的想法，如果你不知道牛人的想法，那你怎么知道自己的想法是很白痴的呢？在这种思想的碰撞过程中，你就会逐渐提高自己！所以，三大框架学完之后，你不应该只是看到一大堆配置文件，你不应该只是看到了一些Action，一些Service，一些映射文件，你不应该只知道session.save/update/delete，你不应该只是知道struts2中有一堆interceptor，你不应该只是看到一堆jar包……

如果你只是知道拷贝一堆jar包，定义一系列配置文件之后，SSH三大框架就能够运行起来了，也可以给你干活了，那么，很悲哀的是，你仍然没有掌握三大框架的精粹！请你回答以下问题：

Struts2：

为什么每次请求都要创建一个Action对象？

ModelDriven拦截器的配置中refreshModelBeforeResult解决了什么问题？

为什么在web.xml中配置的StrutsPrepareAndExecuteFilter要过滤所有的请求？

请你给我谈谈ValueStack？

Struts2是如何实现MVC设计模式的？

Spring：

你为什么要用Spring？

请你聊一聊IOC/DI？

什么是声明式的事务管理？为什么要使用声明式的事务管理？Spring如何实现声明式的事务管理？

把spring和hibernate集成，定义事务管理特性的时候，为何要将除了添加、删除、更新操作之外的方法，即主要执行查询任务的方法定义为read-only？

Hibernate：

请你谈谈你对OR映射的理解？

很多人说Hibernate不适合大项目，性能有问题，你是如何理解的？

Hibernate为什么一定要定义一个数据库标识？

真正的Java学习从入门到精通，只需拿下这6点！

Sat, 16 Sep 2017 19:56:40 +0800

划重点
初入学习Java不知道该何从下手？
有了基础知识，提升技术不知该如何学习？
今天分享一个技能大篇，帮助你实现技术的提升，薪资的高涨，认真看哦！

一、工具篇JDK

JDK是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库(rt.jar)。不论什么Java应用服务器实质都是内置了某个版本的JDK。因此掌握JDK是学好Java的第一步。最主流的JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开发了自己的JDK，例如IBM公司开发的JDK，BEA公司的Jrocket，还有GNU组织开发的JDK等等。其中IBM的JDK包含的JVM（Java Virtual Machine）运行效率要比Sun JDK包含的JVM高出许多。而专门运行在x86平台的Jrocket在服务端运行效率也要比Sun JDK好很多。但不管怎么说，我们还是需要先把Sun JDK掌握好。

1、 JDK的下载和安装

JDK又叫做J2SE（Java2 SDK Standard Edition），可以从Sun的Java网站上下载到，网页链接，JDK当前最新的版本是J2SDK1.4.2，建议下载该版本的JDK，下载页面在这里：网页链接。下载好的JDK是一个可执行安装程序，默认安装完毕后会在C:\Program Files\Java\目录下安装一套JRE（供浏览器来使用），在C:\j2sdk1.4.2下安装一套JDK（也包括一套JRE）。然后我们需要在环境变量PATH的最前面增加java的路径C:\j2sdk1.4.2\bin。这样JDK就安装好了。

2、 JDK的命令工具

JDK的最重要命令行工具：
java：启动JVM执行class
javac： Java编译器
jar： Java打包工具
javadoc： Java文档生成器

这些命令行必须要非常非常熟悉，对于每个参数都要很精通才行。对于这些命令的学习，JDK Documentation上有详细的文档。

Java Web 网站技术架构演化和总结

Fri, 15 Sep 2017 20:00:42 +0800

[分享]工作也有几多年了，无论是身边遇到的还是耳间闻到的，多多少少也积攒了自己的一些经验和思考，当然，博主并没有太多接触高大上的分布式架构实践，相对比较零碎，随时补充。

俗话说的好，冰冻三尺非一日之寒，滴水穿石非一日之功，罗马也不是一天就建成的，当然对于我们开发人员来说，一个好的架构也不是一蹴而就的。

初始搭建

开始的开始，就是各种框架一搭，然后扔到Tomcat容器中跑就是了，这时候我们的文件，数据库，应用都在一个服务器上。

服务分离

随着系统的的上线，用户量也会逐步上升，很明显一台服务器已经满足不了系统的负载，这时候，我们就要在服务器还没有超载的时候，提前做好准备。

由于我们是单体架构，优化架构在短时间内是不现实的，增加机器是一个不错的选择。这时候，我们可能要把应用和数据库服务单独部署，如果有条件也可以把文件服务器单独部署。

反向代理

为了提升服务处理能力，我们在Tomcat容器前加一个代理服务器，我一般使用Nginx，当然你如果更熟悉apache也未尝不可。

用户的请求发送给反向代理，然后反向代理把请求转发到后端的服务器。

严格意义上来说，Nginx是属于web服务器，一般处理静态html、css、js请求，而Tomcat属于web容器，专门处理JSP请求，当然Tomcat也是支持html的，只是效果没Nginx好而已。

反向代理的优势，如下：

隐藏真实后端服务
负载均衡集群
高可用集群
缓存静态内容实现动静分离
安全限流
静态文件压缩
解决多个服务跨域问题
合并静态请求(HTTP/2.0后已经被弱化)
防火墙
SSL以及http2

动静分离

【分享】Java并发面试题精选

Wed, 13 Sep 2017 20:20:01 +0800

1，什么是线程？

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。

2，线程和进程有什么区别？

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。每个线程都拥有单独的栈内存用来存储本地数据。

3，如何在Java中实现线程？

两种方式：java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。

4，Java 关键字volatile 与 synchronized 作用与区别？

1，volatile

它所修饰的变量不保留拷贝，直接访问主内存中的。

在Java内存模型中，有main memory，每个线程也有自己的memory (例如寄存器)。为了性能，一个线程会在自己的memory中保持要访问的变量的副本。这样就会出现同一个变量在某个瞬间，在一个线程的memory中的值可能与另外一个线程memory中的值，或者main memory中的值不一致的情况。一个变量声明为volatile，就意味着这个变量是随时会被其他线程修改的，因此不能将它cache在线程memory中。

2，synchronized

当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用。

5，有哪些不同的线程生命周期？

当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。其他的线程状态还有Waiting，Blocked 和Dead。

6，你对线程优先级的理解是什么？

每一个线程都是有优先级的，一般来说，高优先级的线程在运行时会具有优先权，但这依赖于线程调度的实现，这个实现是和操作系统相关的(OS dependent)。我们可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程优先级是一个int变量(从1-10)，1代表最低优先级，10代表最高优先级。

7，什么是死锁(Deadlock)？如何分析和避免死锁？

死锁是指两个以上的线程永远阻塞的情况，这种情况产生至少需要两个以上的线程和两个以上的资源。

java程序员如何规划自己的职业生涯

Mon, 11 Sep 2017 19:30:20 +0800

IT行业越来越繁荣、成熟，随着移动互联网、java编程语言的普及，愈发有很多java程序员进入这个行业，java程序员面临自身能力提升时更多关注的是自身的硬实力，即技术功底、专业知识; java程序员如何规划自己的职业生涯，软技能的提升与硬实力同等重要，有时可能更为重要。

1. 专注力

在日常工作和生活中，我们可能时常被打断，特别是当我们进行编码工作时被打断后，往往需要半个小时或更长时间来找回当时的工作状态。挑选时间片段专注于单一任务的方法，可以帮助程序员从这种状态中脱离出来。当然自己也要学会建立防火墙，专注时间内的其它可能打扰自己的因素需要及时避免，如即时通信软件、微信等。专注于完成单一任务，不要期望并行任务完成得很好，经常性的被打断会造成专注力的缺失，对于程序员来说缺乏专注力是致命的。

2. 时间管理

总是感觉一天什么都还没有做，时间就溜走了。分享一个我对于时间利用方式的理解，即碎片事情用碎片时间，完整事情用成块时间。怎么理解呢?我们日常有很多的碎片事情，如查邮件、刷微博、看微信等，这样的事情就可以利用碎片时间来做，例如上厕所、等公交、坐地铁等;例如完成产品某一功能便是完整事情，需要利用成块的非打扰时间来完成，这样才会将时间利用好。

3. 对自己负责

不论是提升工作效率，还是学习新的技能，都是在给自己积累经验和知识，在进行工作输出时，需要对自己所完成的内容进行负责，使其达到最好的状态和输出标准，这一切的努力都是在对自己负责。

4. 有效努力工作

加班是程序员跑不掉的话题，需要思考的是，在自己的工作内容里面，完成时到底用了多少有效时间，千万不要只是看上去很努力，做了很多无用功或是浪费了时间。当然，如果你公司文化是由加班多少来决定晋升和绩效的，要么玩这个游戏，要么离开这样的公司。

Java面试经验，兼谈互联网公司后端面试经验

Sun, 10 Sep 2017 19:47:01 +0800

应聘相关

声明：

程序员相关的哈

万事无定论，比如说，就算你小学毕业，但是java基础却扎实到变态，我相信open的公司还是会给你机会的。

心态很重要，虽然日常的心态不容易控制，面试那俩小时的心态，只要你想，就能控制。

1、先来一份前辈的劝戒

坚持三年，不管在哪干，有一个好的平台，坚持三年以上才能出效果。

如果跳的话，新公司需要稳定，最少过了B轮融资，，五万比一是创业型公司的失败率

不要着急，不要比较为了5000块的工资差价跳，不值得跳，从一万到三万，并且有一个好的平台的话，才值得跳。

长期的看普华挺好的，从平台上讲，除了BAT华为，基本没有更好的

每天要多投些简历，每天投个几十份，别着急，多面面。

2、再来一份傲骄的互联网公司的不收标准

符合以下条件的不要

二本以下，特别是学校名XXX学院

应届或者未毕业

在职并且不打算换工作

目标非北京

纯 windows / asp / c# / c sharp / .net / dot net

纯嵌入式

纯移动端 android / iOS

特别底层，比如操作系统内核裁剪

非计算机专业，计算机工作经验在一年以下

最近的项目，空白超过半年，比如现在8月份，项目经历只写到2月

87 年以前，除非背景特别牛

Java集合类

Fri, 08 Sep 2017 21:07:49 +0800

看了一些所谓大公司的JAVA面试问题，发现对于JAVA集合类的使用都比较看重似的，而自己在这方面还真的是所真甚少，抽空也学习学习吧。

java.util包中包含了一系列重要的集合类，而对于集合类，主要需要掌握的就是它的内部结构，以及遍历集合的迭代模式。

接口：Collection

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

主要的一个接口方法：boolean add(Ojbect c)

虽然返回的是boolean，但不是表示添加成功与否，这个返回值表示的意义是add()执行后，集合的内容是否改变了（就是元素的数量、位置等有无变化）。类似的addAll，remove，removeAll，remainAll也是一样的。

用Iterator模式实现遍历集合

Collection有一个重要的方法：iterator()，返回一个Iterator（迭代器），用于遍历集合的所有元素。Iterator模式可以把访问逻辑从不同的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。典型的用法如下：

Iterator it = collection.iterator(); // 获得一个迭代器
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}

不需要维护遍历集合的“指针”，所有的内部状态都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成。

每一种集合类返回的Iterator具体类型可能不同，但它们都实现了Iterator接口，因此，我们不需要关心到底是哪种Iterator，它只需要获得这个Iterator接口即可，这就是接口的好处，面向对象的威力。

要确保遍历过程顺利完成，必须保证遍历过程中不更改集合的内容（Iterator的remove()方法除外），所以，确保遍历可靠的原则是：只在一个线程中使用这个集合，或者在多线程中对遍历代码进行同步。

由Collection接口派生的两个接口是List和Set。　

List接口

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。和下面要提到的Set不同，List允许有相同的元素。

除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

优秀Java程序员的编程风格

Mon, 28 Aug 2017 20:27:03 +0800

格式规范：

4.不要直接使用Tab控制符：不同环境对Tab控制符的解释也是不同的。

命名约定：

1.名称应该具有实际意义

2.使用人们熟悉的名称

3.谨慎使用过长的名字，可以使用简明通用的缩写

4.尽量保留元音字母

5.缩写词的第一个字母大写

6.不要使用大小写来区分的名字

包命名：

1.用你所在组织的域名的倒序小写形式作为包的根限定词

2.使用单独的小写词作为每个包的根名

3.仅当新旧版本二进制兼容的时候，其包可以使用相同的名字，否则，请使用新名字

类型命名：

1.类和接口名中的每个单词的第一个字母大写

类命名：

1.用名词命名类

2.具有成组相关属性，静态服务或者常量的类名字使用复数形式

接口命名：

1.用名词或者形容词命名接口

方法命名：

1.方法名中的第一个单词小写，其后每个单词的第一个字母大写

2.用动词命名方法

3.遵循JavaBean中命名属性访问函数方法：set，get，is

变量命名：

1.变量命中的第一个单词小写，其后的每个单词的第一个字母大写

2.用名词命名变量

3.集合引用名要用复数形式

4.为不重要的临时变量简历并使用一套标准名字

字段命名：

1.使用this字段变量可以区分开局部变量

参数命名：

1.构造函数或者”set”方法给字段分配参数赋值，参数名应该和字段名相同

常量命名：

1.常量的每个单词均大写，单词之间使用下划线连接

文档约定：

1.为使用和维护你的代码的人编写文档

2.注释和代码要同步

3.使用积极的语气，省略无用的词语

注释类型：

1.用文档注释来描述编程接口

2.用标准注释格式隐藏代码而不必删除它们

3.用单行注释解释实现细节

文档注释：

1.在编写代码前描述编程接口

2.为公用，受保护，包，私有成员建立文档

3.为每个包编写总结和概述

4.为包的每个应用程序或组编写概述

注释风格：

1.对所有文档注释使用统一的格式和组织结构

2.关键字，标识符和常量应放到<code>…</code>标签中

3.将代码放入<pre>…</pre>标签中

4.在标识符第一次出现的时候用{@link}标签

5.为Javadoc标签简历并使用一套固定的顺序

6.使用第三人称叙述的形式

7.编写独立的概述

8.省略概述中动作和服务的主语

9.省略事物概述中的对象和动词

10.使用this而不是the来指代当前类中的实例

11.方法名或者构造函数名不需圆括号，除非你想突出一个特殊的签名

注释内容：

1.每个类、接口、字段和方法都编写概述

2.完整描述每个方法的签名

3.包含示例

4.为前置、后置、不变条件编写文档

5.为已知的缺陷和不足编写文档

6.为同步语法编写文档

Java中堆内存和栈内存详解

Sun, 27 Aug 2017 19:13:26 +0800

Java把内存分成两种，一种叫做栈内存，一种叫做堆内存.

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。

堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针!

java中内存分配策略及堆和栈的比较

1 内存分配策略

按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.

静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.

栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。

静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.

2 堆和栈的比较

上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈:

从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:

在编程中，例如C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个”大小多少”是在编译时确定的,不是在运行时.

堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间，因此用堆的效率非常低.但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中，要求创建一个对象时，只需用 new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存.当然，为达到这种灵活性，必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间!这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕~).

3 JVM中的堆和栈

JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说，它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。

我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的.

从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域，该区域具有先进后出的特性。

每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享.跟C/C++不同，Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。

Java 中的堆和栈

Java把内存划分成两种：一种是栈内存，一种是堆内存。

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。

当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

堆内存用来存放由new创建的对象和数组。

在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。

引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。

具体的说：

栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

程序员，如何从平庸走向理想？

Fri, 25 Aug 2017 21:10:04 +0800

我算是靠坑蒙拐骗进了程序员的门，然后一路狂奔。26 岁之前几乎没有任何写代码的经验，研究生毕业却意外选择了一家不可能提供培训的初创公司，在每日担忧公司倒闭、害怕被炒鱿鱼以及同事冷落白眼的三重压力下逆流而上，一年半后离职，已是拥有 500 万用户产品的后台主程。从前我对计算机技术心怀畏惧，认定技术高人一定有佛光笼罩，昼夜不息运键如飞日吐代码上万行。现在也算见过一些世面了，回首那段忐忑不安宛如初夜的过程，我却不发觉有任何的励志意味，而是视为一种理所当然。理想的程序员，和理想的建筑师、理想的财务师、理想的按摩师没有任何的差别，他们本质上都是一群手艺人。我相信理想的程序员人人皆可成为。

近三年总在互联网圈厮混，我认识过一些程序员，共事过一些程序员，领导过一些程序员，又面试过一些程序员。他们学历不同，有的来自北大，有的来自北大青鸟，有的是博士，有的是高中肄业；资历也不同，有的来自 BAT，有的来自某破产基金公司（还是一个销售）；年限也从 0 到 15 年不等。但我认为程序员只需分三类：天才的程序员、理想的程序员、平庸的程序员。天才的程序员我只敢说接触过 3 个，这是天命。7 分由你是颗精子的时候就已决定，拥有绝佳的数学天赋、冷静致密的逻辑、为解决难题宁愿不眠不休而深以为乐的技术热情；3 分来自起步要早早早，恨不得同龄人玩泥巴的时候就得开始玩电脑，大学毕业前就突破一万小时法则，后面的已是游戏人生。

天才的程序员可遇不可求，更不能长有，我看到的 90% 仍是平庸的程序员。IT时代的膨胀，已让程序员如同文艺复兴时的印刷匠一样的普通，多数投入祖师爷门下的人，仅是为了更大的饭碗，更高的待遇，更好的生计。平庸的程序员编写腐烂的代码，没有规范和一致性，固守旧世界的语言，还好谈论大的架构和性能，说的比做的漂亮。而毫无例外的，他们认定技术没有出路，做产品、营销和管理的是更高大上的手艺，而他们当中的 99%，又会自然的流露出自己恰巧具备了那方面的天赋，至于进程为什么会崩溃这样的小问题是不屑于去了解的。

而我最喜欢和理想的程序员相处，恨不得与他们同吃同住，如果允许，我希望我的队伍能插满他们的旗帜。理想的程序员心眼儿不坏（他们从来都不是办公室政治的宠儿，是一群单纯明亮快乐的手艺人），有天真烂漫的好奇心（他们的眼睛里经常闪着「哇，这个是怎么做到的！」），永远精益求精（他们的口头禅是「我再研究一下」），还乐于分享（他们活跃于 GitHub、各大问答社区和你的身边，舍得将宝贵时间用于帮助新手）。是的，他们不需要被管理，只需要给一个大的方向，总能回报以意想不到的结果。

理想的程序员与平庸的程序员只有一墙之隔。两者的差距只有 6 个一点点，而人与人的差距，正是在这日积月累的一点点中，被永远拉开了。有意思的是，我发现这6个一点点都和意识有关，也就是程序员和其他一切新兴产业的工种一样，只需要意识加上时间的锤炼，人人皆可达到理想的阶段。理想的程序员必然也是一个优秀的 problem-solver.

第 1 个一点点：专注眼下

见过太多心猿意马的程序员，我不得不把「专注眼下」作为天字第一条。他们往往有各式各样的小梦想，比如做个小茶农、做个小鹅贩、做产品、做销售、做投资，却被程序员的高薪或是没有转行的魄力「耽误」了，而因为不专注，他们不在意做好自己的本分，不在意锤炼自己的技能，不在意学习新兴的技术。不可否认，这世界上存在着伟大的产品（像乔老爷）、伟大的销售（像埃里森）、伟大的投资客（像彼得菲），而他们毫无例外都是程序员出身。可你听说过巴菲特评价盖茨的话么，比尔盖茨如果转行去卖狗，那他一定是全世界最大的狗贩。我坚信除了少数的天才外，冥冥众生均可以在多个领域取得成功，只要保持足够的专注。而哪怕你下一年就想卖狗去，程序员的经验仍然能训练你强大的逻辑、谨慎和耐心，放在哪个行业都是相当可观的竞争力。

第 2 个一点点：思考力与推动力

我认为处理 bug、崩溃、调优、入侵等突发事件比编程本身更能体现平庸程序员与理想程序员的差距。当面对一个未知的问题时，如何定位复杂条件下的核心问题、如何抽丝剥茧地分析问题的潜在原因、如何排除干扰还原一个最小的可验证场景、如何抓住关键数据验证自己的猜测与实验，都是体现程序员思考力的最好场景。是的，在衡量理想程序员的标准上，思考力比经验更加重要。

有时候小伙伴跑过来，问我「提交了一个任务被卡住了，怎么办」的时候，我总觉得他可以做得更好。比如，可以检查试验别的任务，以排除代码自身的原因；可以通过 Web UI 检查异常（如果没有账号，可以让我提供）；可以排查主机日志或删除缓存，再不济，总应该提供任务 ID 和控制台日志给我。理想的程序员永远不会等事情前进，他们会用尽一切方法让事情前进。

第 3 个一点点：Never Say No

记得从前厂离职之前，找老板谈话，他说我最大的优点就是从来不和他说这个做不到。后来我发现在很多团队里，都存在一种技术和产品的对立，程序员往往以「技术上无法实现」来挡产品的需求，而产品也往往以「Facebook可以为什么我们做不到」来奚落程序员。这两句话应该属于禁语，从根本上都不利于程序猿和产品狗的相亲相爱。

一句「技术上无法实现」是容易出口，可有多少人在说出这句话的时候，心里是 100% 肯定的？如果不肯定，为什么不能回去谷歌一下再回答？原本我以为程序员是充满想象力，在因为有想象力，才能诞生那么多改变我们生活的软件和互联网产品。见识多了，才了解大部分程序员已经在与 bug 的对抗中变得保守而不愿担当风险，与此同时许多团队也不愿意宽容失败。于是「Say No」变成一种习惯性的抵触，还记得曾国藩为什么解散湘军么？他说那支军队已「暮气渐深」，不能打仗了。要做理想的程序员，就不能给自己滋生暮气的机会，如果面对不合理的需求，可以把时间成本摆出来，把曲线救国方案亮出来，简单粗暴「Say No」是不可取的。

第 4 个一点点：投资未来

程序员是一个非常残忍的职业。你所学所用的语言、框架、模式，很可能在数年内就成昨日黄花了；你现在嘲笑的另一群程序员，可能马上就能转身来嘲笑你了。所以理想的程序员除了做好自己的本分，还要花费时间来投资未来。什么是「投资」？投资就是你现在投入的时间，在未来会以更多的时间或者金钱（看看早几年学习 iOS 的程序员现在的薪酬！）回报你。举我自己的领域 — 数据挖掘为例，08 年左右 Hadoop 开始兴起，一时「大数据」概念火热，Hadoop 工程师万金难求，各互联网公司纷纷把数据统计、数据分析和数据挖掘的业务切换到分布式平台上。这几年眼看 Hadoop 还在不断迭代，Spark 又异军突起，一举刷新了 Hadoop 保持的排序记录，以内存存储中间数据带来的性能优势和丰富的数据结构让人爱个不停，各种奇异的小 bug 和陡峭的学习曲线又让人打退堂鼓。那么，明眼人都知道 Spark 是未来的趋势（内存会越来越便宜），在主业务放在 Hadoop 的条件下，就可以适当把一些小模块切换到 Spark 上，同时留意 Spark 社区的发展。很快从 Spark 获得的性能收益就能把之前投入的学习时间挣回来。

Java My SQL 数据库用法操作代码

Tue, 22 Aug 2017 14:09:56 +0800

各数据库连接代码

//Oracle8/8i/9i数据库(thin模式)

String url="jdbc:oracle:thin:@localhost:1521:orcl";

String user="scott";

String password="tiger";

Connection conn=DriverManager.getConnection(url,user,password);

//Sql Server7.0/2000/2005/2008数据库

String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";

String user="sa";

String password="";

Connection conn=DriverManager.getConnection(url,user,password);

//DB2数据库

String url="jdbc:db2://localhost:5000/sample";

String user="amdin"

String password=-"";

Connection conn=DriverManager.getConnection(url,user,password);

//MySQL数据库

String url="jdbc:mysql://localhost:3306/testDB?user=root&password=root&useUnicode=true&characterEncoding=gb2312";

Connection conn=DriverManager.getConnection(url);

一下是进行增删改查的mysql代码

增：insert into user//表名(***//表头) values(****//增加的数据)";

改：update user//表名 set userName//表头 ='"+field2+"//修改的数据',passwork='"+field3+"',teacherID="+Integer.parseInt(field4)+" where userID="+Integer.parseInt(field1);

删：delete from user where userID="+Integer.parseInt(field1//字符串类型的要先转换成整型的);

查：select * from userID//查询表中的某个表头 order by User//表名

JAVA修改、删除数据之后刷新JTable的方法

Sun, 20 Aug 2017 17:04:58 +0800

以下代码不完整，仅把关键的代码贴出来

String userTitle[] = {"ID","用户名","密码","邮箱","名字","等级"};

tab = new Object[userInfoNumber][6];

Iterator<User> iter = userList.iterator();

while(iter.hasNext()){

User user = iter.next();

tab[i][0] = user.getId();

tab[i][1] = user.getUserName();

tab[i][2] = user.getPwd();

tab[i][3] = user.getMail();

tab[i][4] = user.getName();

whatGrade = user.getGrade() == 1 ? "管理员" : "普通会员";

tab[i][5] = whatGrade;

i ++;

}

DefaultTableModel tableModel = new DefaultTableModel(tab,userTitle);

JTable table = new JTable(tableModel);

for(int j = 0;j < table.getRowCount();j ++){

导出含有图片的Java项目，图片不显示

Sun, 20 Aug 2017 16:55:36 +0800

项目的一些图片资源文件在导出成JAR包后，无法正确读取虽然Java项目还是可以运行，但原来的图片资源全不见了，于是你可以打开JAR包看看里面的东西，确实是有图片在里面，就是无法读取。

其实是因为我们在导出成JAR包后，图片资源的路径已经发生了变化，造成无法读取的问题

首先在项目的SRC目录下建立一个包，然后再把图片等资源放进包中，然后再通过下面的方法进行读取：

ImageIcon img = new ImageIcon(【你的主类名称】.class.getgetResource("/pic/index.png"));

比如我在SRC目录下建立了一个pic包，包下面放了一张图片index.png，我的读取图片主类是MySample，那么我需要读取index.png这张图片时就要这样做：

ImageIcon indexImage = new ImageIcon(MySample.class.getgetResource("/pic/index.png"));

要注意的是路径中pic前面的斜杠不可少，否则会报错读取不到资源造成空指针，其他如音频资源也是类似做法。

转载自【Java编程精选】关于 Java 你不知道的十件事

Sat, 19 Aug 2017 20:49:33 +0800

作为Java 控，我们总是对不太可能直接使用，但能使我们更了解 Java 和 Java 虚拟机（Java Virtual Machine，JVM）的晦涩细节感兴趣。这也是我将 Lukas Eder 在 jooq.org 上写的这篇文章发布出来的原因。

你在Java发布的时候就开始使用了吗？还记得那时它叫“Oak”，面向对象也（Object Oriented， OO ）还是个热门话题，C++ 程序员们觉得 Java 完全没机会成功，Applet的出现也是一件新鲜大事？

我打赌下文中至少一半的内容你都不知道。让我们来看看这些令人惊喜的 Java 细节吧。

1. 受检异常（checked exception）这件事是不存在的

是这样的，JVM 完全不知道这件事，都是Java语言做的[只有Java语言这么干]。

现在，异常检查被公认为是个错误，正如 Brue Eckel 在布拉格的 GeeCON 大会上的闭幕词中所说， Java 后的其他语言都不再使用异常检查了，就连 Java 8 都不愿在新的 Stream API 中使用它了（当你在 lambda 表达式中使用 IO 或者 JDBC 时，是很痛苦的）。

你想要证明 JVM 不知道异常检查这件事吗？尝试以下代码：

这个不仅会编译，还会抛出 SQLException ，你甚至不需要 Lombok 的 @SneakyThrows 标签。

更多详情请参考这篇文章，或者 Stack Overflow 上的这篇文章。

2. 可以使用不同的返回值类型来重载方法

以下代码是编译不过的，对吧？

java.lang.StackOverflowError 异常解决办法

Sat, 19 Aug 2017 19:43:46 +0800

这个错误是相互引用,导致连锁栈溢出,不知道那块循环没有停下来所以进程就一直在跑

我一直在找到底哪的循环没停下来然后还是没找到。直接调用没错误就是加表格上就出错别的窗口都没错误就是这个论文查询有错误

到最后发现就是接口调用的时候写错单词了心里十万个草泥马奔腾而过

这个错误的官方解释是：

递归调用没有明确的结束

仔细查看自己的递归调用程序

举例：递归没有边界条件或者递归的边界条件永远不能达到

所以你就找找你哪里少写了几句实在不行就重写

结论：没有找不到的Bug 只有不努力没有耐心的人

科研管理系统--ResAbout 关于界面代码设计

Fri, 18 Aug 2017 20:11:06 +0800

package view;

import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Image;
import java.awt.Insets;
import java.awt.MediaTracker;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import java.net.URLClassLoader;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

import com.jnzj.common.Commom;

public class ResAbout extends JFrame implements ActionListener{
	Image icon;
	ImageIcon banner;
	JLabel jLabel;
	JLabel jLabel2;
	JLabel jLabel3;
	JLabel jLabel4;
	JLabel jLabel5;
	JPanel jPanel;
	JPanel jPanel2;
	JPanel jPanel3;
	JButton jButton;
	private GridBagConstraints girdBagCon;
	private GridBagLayout girdBag=new GridBagLayout();
	public ResAbout() {
		// TODO Auto-generated constructor stub
		this.setLayout(new BorderLayout());//边框布局
		//enableEvents(AWTEvent.WINDOW_EVENT_MASK);
		//添加框架的关闭时间处理2
		//this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//窗口自适应大小 使窗体能正好显示里面的所有控件
		this.pack();
		//设置框架的大小
		this.setSize(500,400);
		//设置窗体的标题
		this.setTitle("关于");
		//调用自定义的方法GetImage（） ，获取图标文件
		icon=getImage("icon.png");
		//设置窗体图标
		this.setIconImage(icon);
		//设置不能调整窗体的大小
		this.setResizable(false);
		//获取屏幕大小
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		//获取当前项目的窗体大小
		Dimension frameSize=this.getSize();
		//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
		if (frameSize.height>screenSize.height) {
			frameSize.height=screenSize.height;
		}
		if (frameSize.width>screenSize.width) {
			frameSize.width=screenSize.width;
		}
		//设置窗体起始显示位置 居中显示
		this.setLocation((screenSize.width-frameSize.width)/2,
		(screenSize.height-frameSize.height)/2);
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
				| UnsupportedLookAndFeelException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		try {
			top();
			central();
			down();
			addListener();//监听
			this.setVisible(true);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		
	}
	private void addListener() {
		// TODO Auto-generated method stub
		jButton.addActionListener(this);
		
	}
	public void top() {
		jPanel=new JPanel();
		jPanel.setLayout(girdBag);
		jLabel=new JLabel("1.科研管理系统V1.0\t");
		jLabel.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel, girdBagCon);

		jLabel2=new JLabel("2.版权归2017doft公司所有 翻录必究");
		jLabel2.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=2;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel2, girdBagCon);
		
		jLabel3=new JLabel("3.联系方式：");
		jLabel3.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=3;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel3, girdBagCon);
		
		jLabel4=new JLabel("4.我们的口号是：代码演绎人生 算法助推梦想");
		jLabel4.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=4;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel4, girdBagCon);
		jPanel.add(jLabel);
		jPanel.add(jLabel);
		jPanel.add(jLabel2);
		jPanel.add(jLabel3);
		jPanel.add(jLabel4);	
		this.add(jPanel,BorderLayout.NORTH);
		
	}
	public void central() {
		jPanel2=new JPanel();

		banner=new ImageIcon("res/image.png");
		jLabel5=new JLabel(banner);
		jPanel2.add(jLabel5);
		this.add(jPanel2,BorderLayout.CENTER);
	}
	public void down() {
		jPanel3=new JPanel();
		this.add(jPanel3,BorderLayout.SOUTH);
		jButton=new JButton("关闭");
		jPanel3.add(jButton);
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object object=e.getSource();
		if (object==jButton) {
			this.setVisible(false);
		}
		
	}

	/** * 通过给定的文件名获得图像 */
	
	Image getImage(String filename){ 
		//URLClassLoader--用于从指向 jar文件和目录的 URL 的搜索路径加载类和资源。
		URLClassLoader urlLoader=(URLClassLoader) this.getClass().getClassLoader(); 
		
		URL url=null; 
		Image image=null;
		url=urlLoader.findResource(filename); 
		image=Toolkit.getDefaultToolkit().getImage(url); 
		MediaTracker mediaTracker=new MediaTracker(this); 
		 try { 
			 mediaTracker.addImage(image, 0); 
			 mediaTracker.waitForID(0); 
		 }catch (InterruptedException _ex){
			 image=null;
		 }
		 if (mediaTracker.isErrorID(0)) {
			 image=null;
		 }
		 return image;
	}
}

科研管理系统--ResHelp 帮助界面代码设计

Fri, 18 Aug 2017 20:08:24 +0800

package view;

import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Image;
import java.awt.Insets;
import java.awt.MediaTracker;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import java.net.URLClassLoader;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

import com.jnzj.common.Commom;

public class ResHelp extends JFrame implements ActionListener{
	Image icon;
	ImageIcon banner;
	JLabel jLabel6;
	JLabel jLabel;
	JLabel jLabel2;
	JLabel jLabel3;
	JLabel jLabel4;
	JLabel jLabel5;
	JPanel jPanel;
	JPanel jPanel2;
	JPanel jPanel3;
	JButton jButton;
	private GridBagConstraints girdBagCon;
	private GridBagLayout girdBag=new GridBagLayout();
	public ResHelp() {
		// TODO Auto-generated constructor stub
		this.setLayout(new BorderLayout());//边框布局
		//enableEvents(AWTEvent.WINDOW_EVENT_MASK);
		//添加框架的关闭时间处理2
		//this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//窗口自适应大小 使窗体能正好显示里面的所有控件
		this.pack();
		//设置框架的大小
		this.setSize(700,200);
		//设置窗体的标题
		this.setTitle("帮助");
		//调用自定义的方法GetImage（） ，获取图标文件
		icon=getImage("icon.png");
		//设置窗体图标
		this.setIconImage(icon);
		//设置不能调整窗体的大小
		this.setResizable(false);
		//获取屏幕大小
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		//获取当前项目的窗体大小
		Dimension frameSize=this.getSize();
		//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
		if (frameSize.height>screenSize.height) {
			frameSize.height=screenSize.height;
		}
		if (frameSize.width>screenSize.width) {
			frameSize.width=screenSize.width;
		}
		//设置窗体起始显示位置 居中显示
		this.setLocation((screenSize.width-frameSize.width)/2,
		(screenSize.height-frameSize.height)/2);
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
				| UnsupportedLookAndFeelException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		try {
			top();
			central();
			down();
			addListener();//监听
			this.setVisible(true);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		
	}
	private void addListener() {
		// TODO Auto-generated method stub
		jButton.addActionListener(this);
		
	}
	public void top() {
		
		jPanel2=new JPanel();
		jPanel2.setLayout(girdBag);
		jLabel6=new JLabel("科研管理系统帮助");
		jLabel6.setFont(new Font("Dialog", 0, 16));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=0;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 10, 0, 10);
		girdBag.setConstraints(jLabel6, girdBagCon);
		jPanel2.add(jLabel6);
		this.add(jPanel2,BorderLayout.NORTH);
	}
	public void central() {
		jPanel=new JPanel();
		jPanel.setLayout(girdBag);
		jLabel=new JLabel("1.科研管理系统是为了统计高校教师的科研成果");
		jLabel.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel, girdBagCon);

		jLabel2=new JLabel("2.以论文信息的统计为例子");
		jLabel2.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=2;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel2, girdBagCon);
		
		jLabel3=new JLabel("3.该论文系统实现了论文信息，作者信息，作者所在部门信息的管理，包括：添加，删除和修改");
		jLabel3.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=3;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel3, girdBagCon);
		
		jLabel4=new JLabel("4.该系统实现了论文信息，作者信息，作者和所在部门的不同条件查询");
		jLabel4.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=4;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		//girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel4, girdBagCon);
		jPanel.add(jLabel);
		jPanel.add(jLabel2);
		jPanel.add(jLabel3);
		jPanel.add(jLabel4);	
		this.add(jPanel,BorderLayout.CENTER);
		
	}
	public void down() {
		jPanel3=new JPanel();
		this.add(jPanel3,BorderLayout.SOUTH);
		jButton=new JButton("关闭");
		jPanel3.add(jButton);
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object object=e.getSource();
		if (object==jButton) {
			this.setVisible(false);
		}
		
	}

	/** * 通过给定的文件名获得图像 */
	
	Image getImage(String filename){ 
		//URLClassLoader--用于从指向 jar文件和目录的 URL 的搜索路径加载类和资源。
		URLClassLoader urlLoader=(URLClassLoader) this.getClass().getClassLoader(); 
		
		URL url=null; 
		Image image=null;
		url=urlLoader.findResource(filename); 
		image=Toolkit.getDefaultToolkit().getImage(url); 
		MediaTracker mediaTracker=new MediaTracker(this); 
		 try { 
			 mediaTracker.addImage(image, 0); 
			 mediaTracker.waitForID(0); 
		 }catch (InterruptedException _ex){
			 image=null;
		 }
		 if (mediaTracker.isErrorID(0)) {
			 image=null;
		 }
		 return image;
	}
}

科研信息管理系统-论文管理之菜单导航版

Thu, 17 Aug 2017 17:21:03 +0800

package view;

import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import java.net.URLClassLoader;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.plaf.basic.BasicBorders;

public class ResearchMain extends JFrame implements ActionListener{
	//框架大小
	Dimension faceSize=new Dimension(950, 650);
	Image icon;
	ImageIcon banner;
	//程序图标
	JPanel panel1;
	JLabel jLabel;

	JMenuBar menuBar;
	
	JMenu menu1;
	JMenu menu2;
	JMenu menu3;
	JMenu menu4;
	JMenu menu5;
	
	JMenuItem item1;
	JMenuItem item2;
	JMenuItem item3;
	JMenuItem item4;
	JMenuItem item5;
	JMenuItem item6;
	JMenuItem item7;
	JMenuItem item8;
	JMenuItem item9;
	JMenuItem item10;
	
	//boolean packFame=false;
	public ResearchMain() {
		this.setLayout(new BorderLayout());//边框布局
		enableEvents(AWTEvent.WINDOW_EVENT_MASK);
		//添加框架的关闭时间处理2
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//窗口自适应大小 使窗体能正好显示里面的所有控件
		this.pack();
		//设置框架的大小
		this.setSize(faceSize);
		//设置窗体的标题
		this.setTitle("科研信息管理系统");
		//调用自定义的方法GetImage（） ，获取图标文件
		icon=getImage("icon.png");
		//设置窗体图标
		this.setIconImage(icon);
		//设置不能调整窗体的大小
		this.setResizable(false);
		//获取屏幕大小
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		//获取当前项目的窗体大小
		Dimension frameSize=this.getSize();
		//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
		if (frameSize.height>screenSize.height) {
			frameSize.height=screenSize.height;
		}
		if (frameSize.width>screenSize.width) {
			frameSize.width=screenSize.width;
		}
		//设置窗体起始显示位置 居中显示
		this.setLocation((screenSize.width-frameSize.width)/2,
		(screenSize.height-frameSize.height)/2);
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
				| UnsupportedLookAndFeelException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		try {
			bt();//初始化标题栏
			gj();//工具栏
			tp();//图片
			addListener();//监听
			this.setVisible(true);
	
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}		
		
	}
	public void bt() {
		menuBar=new JMenuBar();
		this.setJMenuBar(menuBar);
		menu1=new JMenu("系统设置");
		menuBar.add(menu1);
		menu2=new JMenu("论文信息管理");
		menuBar.add(menu2);
		menu3=new JMenu("教师信息管理");
		menuBar.add(menu3);
		menu4=new JMenu("部门信息管理");
		menuBar.add(menu4);
		menu5=new JMenu("帮助");
		menuBar.add(menu5);
		item1=new JMenuItem("用户管理");
		item2=new JMenuItem("退出系统");
		menu1.add(item1);
		menu1.add(item2);
		item3=new JMenuItem("论文信息管理");
		item4=new JMenuItem("论文信息查询");
		menu2.add(item3);
		menu2.add(item4);
		item5=new JMenuItem("教师基本信息管理");
		item6=new JMenuItem("教师基本信息查询");
		menu3.add(item5);
		menu3.add(item6);
		item7=new JMenuItem("部门基本信息管理");
		item8=new JMenuItem("部门基本信息查询");
		menu4.add(item7);
		menu4.add(item8);
		item9=new JMenuItem("帮助");
		item10=new JMenuItem("关于");
		menu5.add(item9);
		menu5.add(item10);
		menuBar.setVisible(true);
		
	}
	public void gj() {
		JToolBar toolBar = new JToolBar(); 
		JButton ambtn,asbtn,tmbtn,dmbtn,help,about; 
		ambtn=new JButton(new ImageIcon("res/card.png"));
		asbtn=new JButton(new ImageIcon("res/folder.png"));
		tmbtn=new JButton(new ImageIcon("res/info.png"));
		dmbtn=new JButton(new ImageIcon("res/save.png"));
		help=new JButton(new ImageIcon("res/help.png"));
		about=new JButton(new ImageIcon("res/user.png"));
		toolBar.add(ambtn);
		toolBar.add(asbtn);
		toolBar.add(tmbtn);
		toolBar.add(dmbtn);
		toolBar.add(help);
		toolBar.add(about);
		this.add(toolBar,BorderLayout.NORTH);
	}
	public void tp() {
		banner=new ImageIcon("res/image.png");
		jLabel=new JLabel(banner);
		panel1=new JPanel();
		panel1.add(jLabel);
		this.add(panel1,BorderLayout.CENTER);
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new ResearchMain();
		
	}

	/** * 通过给定的文件名获得图像 */
	
	Image getImage(String filename){ 
		//URLClassLoader--用于从指向 jar文件和目录的 URL 的搜索路径加载类和资源。
		URLClassLoader urlLoader=(URLClassLoader) this.getClass().getClassLoader(); 
		
		URL url=null; 
		Image image=null;
		url=urlLoader.findResource(filename); 
		image=Toolkit.getDefaultToolkit().getImage(url); 
		MediaTracker mediaTracker=new MediaTracker(this); 
		 try { 
			 mediaTracker.addImage(image, 0); 
			 mediaTracker.waitForID(0); 
		 }catch (InterruptedException _ex){
			 image=null;
		 }
		 if (mediaTracker.isErrorID(0)) {
			 image=null;
		 }
		 return image;
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object obj=e.getSource();
		if (obj==item2) {
			System.exit(0);
		}
		
	}
	public void addListener() {
		item2.addActionListener(this);
	}
	
}

eclipse快速生成set get方法以及构造方法

Thu, 17 Aug 2017 16:59:13 +0800

在eclipse中按快捷键 alt + shift + s 选择generate constructor using fields。然后在弹出框中选择成员变量即可快速创建构造方法。

生成set get方法：

在合适的地方采用快捷键 Shift+Alt+S

选择红框中的Generate Getter and Setter再选择需要实现get、set的参数

eclipse快捷键大全

Wed, 16 Aug 2017 20:21:43 +0800

1 几个最重要的快捷键

代码助手:Ctrl+Space（简体中文操作系统是Alt+/）
快速修正：Ctrl+1
单词补全：Alt+/
打开外部Java文档：Shift+F2

显示搜索对话框：Ctrl+H
快速Outline：Ctrl+O
打开资源：Ctrl+Shift+R
打开类型：Ctrl+Shift+T
显示重构菜单：Alt+Shift+T

上一个/下一个光标的位置：Alt+Left/Right
上一个/下一个成员（成员对象或成员函数）：Ctrl+Shift+Up/Down
选中闭合元素：Alt+Shift+Up/Down/Left/Right
删除行：Ctrl+D
在当前行上插入一行：Ctrl+Shift+Enter
在当前行下插入一行： Shift+Enter
上下移动选中的行：Alt+Up/Down

组织导入：Ctrl+Shift+O

2 定位

2.1 行内定位

行末/行首：End/Home
前一个/后一个单词：Ctrl+Right/Left

2.2 文件内定位

跳到某行：Ctrl+L
上下滚屏：Ctrl+Up/Down
上一个/下一个成员（成员对象或成员函数）：Ctrl+Shift+Up/Down
快速Outline：Ctrl+O

2.3 跨文件定位

打开声明：F3
打开资源：Ctrl+Shift+R
打开类型：Ctrl+Shift+T
在workspace中搜索选中元素的声明：Ctrl+G
在workspace中搜索选中的文本：Ctrl+Alt+G
在workspace中搜索选中元素的引用：Ctrl+Shift+G
打开调用层次结构：Ctrl+Alt+H
快速层次结构：Ctrl+T
反悔：Ctrl+Z

2.4 其它

上一个/下一个光标所在位置：Alt+Left/Right
上一个编辑的位置：Ctrl+Q

3 选中

3.1 行内选中

选中到行末/行首：Shift+End/Home
选中上一个/下一个单词：Ctrl+Shift+Left/Right

3.2 文件内选中

选中闭合元素：Alt+Shift+Up
恢复到上一个选中：Alt+Shift+Down
选中下一个/上一个元素：Alt+Shift+Right/Left

4 定位/选中/操作同时

删除行：Ctrl+D
删除下一个/上一个单词：Ctrl+Delete/Backspace
删除到行末：Ctrl+Shift+Delete
在当前行上插入一行：Ctrl+Shift+Enter
在当前行下插入一行： Shift+Enter
上下移动选中的行：Alt+Up/Down
拷贝选中的行：Ctrl+Alt+Up/Down

5 其它的代码编辑类快捷键

保存：Ctrl+S
保存所有：Ctrl+Shift+S
下一个命中的项（搜索之后）：Ctrl+.
注释：Ctrl+/
添加导入：Ctrl+Shift+M
显示快捷键帮助：Ctrl+Shift+L
变为大/小写：Ctrl+Shift+X/Y

6 重构

显示重构菜单：Alt+Shift+T
重构-改变方法签名：Alt+Shift+C
重构-移动：Alt+Shift+V
重构-重命名：Alt+Shift+R

7 编辑器、视图、透视图切换

下一个编辑器：Ctrl+F6
下一个视图：Ctrl+F7
下一个透视图：Ctrl+F8
最大化当前视图或编辑器：Ctrl+M
激活编辑器：F12

8 Debug

F5：Step Into（debug）
F6：Step over（debug）
F7：Step return（debug）
F8：Resume（debug）
F11：debug上一个应用（debug）

9 Up/Down/Right/Left类快捷键

Ctrl
前一个/后一个单词：Ctrl+Right/Left
上下滚屏：Ctrl+Up/Down

Alt
上一个/下一个光标的位置：Alt+Left/Right
上下移动选中的行：Alt+Up/Down
Shift
选中上一个/下一个字符：Shift+Left/Right
选中上一行/下一行（从当前光标位置开始）：Shift+Up/Down

Ctrl+Shift
上一个/下一个成员（成员对象或成员函数）：Ctrl+Shift+Up/Down
选中上一个/下一个单词：Ctrl+Shift+Left/Right

Alt+Shift
选中闭合元素：Alt+Shift+Up
恢复到上一个选中：Alt+Shift+Down
选中下一个/上一个元素：Alt+Shift+Right/Left
拷贝选中的行：Ctrl+Alt+Up/Down

Ctrl+Alt
拷贝选中的行：Ctrl+Alt+Up/Down

10 F类快捷键

F2：显示提示/重命名
F3：打开选中元素的声明
F4：打开选中元素的类型继承结构
F5：刷新
F5：Step Into（debug）
F6：Step over（debug）
F7：Step return（debug）
F8：Resume（debug）
F11：debug上一个应用（debug）
F12：激活编辑器

补充：

Ctrl+1 快速修复(最经典的快捷键,就不用多说了)
Ctrl+D: 删除当前行
Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
Ctrl+Alt+↑ 复制当前行到上一行(复制增加)
Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt+↑ 当前行和上面一行交互位置(同上)
Alt+← 前一个编辑的页面
Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)
Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性
Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift+Ctrl+Enter 在当前行插入空行(原理同上条)
Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)
Ctrl+M 最大化当前的Edit或View (再按则反之)
Ctrl+/ 注释当前行,再按则取消注释
Ctrl+O 快速显示 OutLine
Ctrl+T 快速显示当前类的继承结构
Ctrl+W 关闭当前Editer
Ctrl+K 参照选中的Word快速定位到下一个
Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
Ctrl+/(小键盘) 折叠当前类中的所有代码
Ctrl+×(小键盘) 展开当前类中的所有代码
Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)
Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
Ctrl+J 正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X 把当前选中的文本全部变味小写
Ctrl+Shift+Y 把当前选中的文本全部变为小写
Ctrl+Shift+F 格式化当前代码
Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

MySQL多关键字多字段模糊查询

Wed, 16 Aug 2017 20:18:48 +0800

sql="select *,teacher.teacherID as teacherName, "
					+ "department.depID as depName "
					+ "from teacher,article,department "
					+ "where teacher.teacherID=article.teacherID and department.depID=article.depID and articleName like '%"+f2+"%' "//查询关键字
					+ "and teacherName like '%"+f3+"%' "
					+ "and year like '%"+f6+"%' "
					+ "and depName like '%"+f9+"%' "
					+ "order by articleID";

Java判断两个汉字是否相等

Tue, 15 Aug 2017 19:01:04 +0800

今天试了下用if语句判断两个汉字是否相等结果两个相等的汉字也会else 从网上查了查用下面语句不会出错：

String str1 = new String("");
String str2 = new String("");
str1.equals(str2)(相等时为true)
或str1.compareTo(str2)（只有在.equals()返回true时才为0）

科研信息管理系统---论文信息管理（及修改，删除，增加，查询为一体）

Tue, 15 Aug 2017 18:59:24 +0800

	package com.jnzyjsxy.node1;

	import java.awt.BorderLayout;
	import java.awt.Dimension;
	import java.awt.Font;
	import java.awt.GridBagConstraints;
	import java.awt.GridBagLayout;
	import java.awt.Insets;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
	import javax.swing.JOptionPane;
	import javax.swing.JPanel;
	import javax.swing.JScrollPane;
	import javax.swing.JTable;
	import javax.swing.JTextField;
	import javax.swing.ListSelectionModel;
	import javax.swing.event.ListSelectionEvent;
	import javax.swing.event.ListSelectionListener;

import com.jnzyjsxy.common.ArticleBean;
import com.jnzyjsxy.common.Department;
import com.jnzyjsxy.common.TeacherBean;
//import com.jnzyjsxy.common.HistrinBeanb;
	//import com.jnzyjsxy.common.PersonBean;
	import com.jnzyjsxy.test.KyMain;
import com.jnzyjsxy.test.text;

	/*
	 * 人员删除管理
	 */
	public class Node11Panel extends JPanel implements ListSelectionListener,ActionListener,ItemListener{

		//创建上中下面板
		JPanel upPanel =new JPanel();
		JPanel centerPanel=new JPanel();
		JPanel downpanel =new JPanel();
		//定义图形界面元素
		String DeptID="1";//部门编号
		String teacher="1";
		JComboBox jComboBox11=null;//显示人员所在部门
		JComboBox jComboBox12=null;//显示人员所在部门
		JLabel jLabel=new JLabel();
		JLabel jLabel1=new JLabel();
		JLabel jLabel2=new JLabel();
		JLabel jLabel3=new JLabel();
		JLabel jLabel4=new JLabel();
		JLabel jLabel5=new JLabel();
		JLabel jLabel6=new JLabel();
		JLabel jLabel7=new JLabel();
		JLabel jLabel8=new JLabel();
		JLabel jLabel9=new JLabel();
		JLabel jLabel10=new JLabel();
		JLabel jLabel11=new JLabel();
		//JLabel jLabel3=new JLabel();
		
		JTextField jTextField1=new JTextField(15);
		JTextField jTextField2=new JTextField(15);
		JTextField jTextField3=new JTextField(15);
		JTextField jTextField4=new JTextField(15);
		JTextField jTextField5=new JTextField(15);
		JTextField jTextField6=new JTextField(15);
		JTextField jTextField7=new JTextField(15);
		JTextField jTextField8=new JTextField(15);
		JTextField jTextField9=new JTextField(15);
		JTextField jTextField10=new JTextField(15);
		JTextField jTextField11=new JTextField(15);
		
		JButton hq=new JButton();
		JButton addInfo=new JButton();
		JButton modifyInfo=new JButton();
		JButton deleteInfo=new JButton();
		JButton clearInfo=new JButton();
		
		
		JScrollPane jScrollPane1;
		JScrollPane jScrollPane2;
		
		//创建网格包布局对象
		GridBagLayout girdBag=new GridBagLayout();
		//创建网格包约束类变量
		GridBagConstraints girdBagCon;
		
		//定义表格变量
		JTable jTable;
		//ListSelectionModel列表选中模式类 用于设置JTable中记录选中的模式
		ListSelectionModel ListSelectionModel=null;
		//字符数组 存储列明 对应person 列名
		String[] colName={"编号","题目","作者","期刊/出版社","级别","发表时间","第几期","字数","部门编号","统计日期","备注"};
		//二维数组 存储每一行的记录纸行存储记录编号 列存储该记录各列值
		String[][] colValue;
		GridBagLayout girBag =new GridBagLayout();
		GridBagConstraints gridBagCon;
		
		
		//构造方法
		public Node11Panel() {
			// TODO Auto-generated constructor stub
			this.setLayout(new BorderLayout());//边框布局
			try {
				upInit();//上
				centenInit();
				//panelInit panelInit=new panelInit();
				//this.add(panelInit,BorderLayout.CENTER);//中
				//downInit();//下
				addListener();//监听
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
		//上布局
		public void upInit() {
			//创建人员数据操作类 以便调用该类方法
			ArticleBean bean=new ArticleBean();
			//上部采用网格包不几乎 放置人员信息删除标签和包含表格的滚动面板
			upPanel.setLayout(girBag);
			try {
				//在上部添加标签 
				jLabel.setText("论文信息管理");
				jLabel.setFont(new Font("Dialog", 0, 16));
				gridBagCon=new GridBagConstraints();
				gridBagCon.gridx=0;
				gridBagCon.gridy=0;
				//外部填充 4个参数 top,left,bottom,right
				//既外部间距
				gridBagCon.insets=new Insets(0, 10, 0, 10);
				girBag.setConstraints(jLabel, gridBagCon);
				upPanel.add(jLabel);
				
				//调用Person类的searchAll 方法 获取所有的人员记录
				colValue=bean.searchAllForNode();
				//初始化表对象 2个参数 下面是JTable的构造
				//JTable(Object[][] rowData, Object[] columnNames) 
				 // 构造一个 JTable 来显示二维数组 rowData 中的值，其列名称为 columnNames
				//即第1个参数二维数组存储每一行的值，第2个参数一维数组存放列名称 
				jTable=new JTable(colValue,colName);
				//设置表的大小
				jTable.setPreferredScrollableViewportSize(new Dimension(750,350));
				//初始化表格选择模式对象
				ListSelectionModel=jTable.getSelectionModel();
				//设置表格为单选模式
				ListSelectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
				//添加选择监听事件
				ListSelectionModel.addListSelectionListener(this);
				//把表格放进滚动栏 
				jScrollPane1=new JScrollPane(jTable);
				//设置滚动面板大小
				jScrollPane1.setPreferredSize(new Dimension(750, 350));
				//把滚动面板放在标签的下面
				gridBagCon=new GridBagConstraints();
				gridBagCon.gridx=0;
				gridBagCon.gridy=1;
				gridBagCon.insets=new Insets(0, 0, 0, 0);
				girBag.setConstraints(jScrollPane1, gridBagCon);
				upPanel.add(jScrollPane1);
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
			//添加上部面板
			this.add(upPanel,BorderLayout.NORTH);
		}
		//中部面板
		
		public void centenInit() throws Exception{
			//中间放组件的面板 采用网格包布局
			centerPanel.setLayout(girdBag);
			//第一行组件
			//griy=1 实际的第二行 显示4个组件 gridx依次增加
			jLabel1.setText("论文编号");
			jLabel1.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(0, 10, 10, 1);
			girdBag.setConstraints(jLabel1, girdBagCon);
			centerPanel.add(jLabel1);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=1;
			girdBagCon.insets=new Insets(0, 1, 10, 15);
			girdBag.setConstraints(jTextField1, girdBagCon);
			centerPanel.add(jTextField1);
			
			jLabel2.setText("论文题目");
			jLabel2.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(0, 15, 10, 1);
			girdBag.setConstraints(jLabel2, girdBagCon);
			centerPanel.add(jLabel2);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=1;
			girdBagCon.insets=new Insets(0, 1, 10, 10);
			girdBag.setConstraints(jTextField2, girdBagCon);
			centerPanel.add(jTextField2);
			
			jLabel3.setText("作者");
			jLabel3.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=4;
			girdBagCon.gridy=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel3, girdBagCon);
			centerPanel.add(jLabel3);
			
			TeacherBean teacherBean=new TeacherBean();
			String[] alltype=teacherBean.searchAllForNode();
			//jComboBox11.setPreferredSize(new Dimension(125, 25));
			jComboBox11=new JComboBox(alltype);
			
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=5;
			girdBagCon.gridy=1;
			girdBagCon.insets=new Insets(10, 1, 10, 15);
			girdBag.setConstraints(jComboBox11, girdBagCon);
			centerPanel.add(jComboBox11);
			
			jLabel4.setText("期刊名称");
			jLabel4.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=2;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 15, 10, 1);
			girdBag.setConstraints(jLabel4, girdBagCon);
			centerPanel.add(jLabel4);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=2;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField4, girdBagCon);
			centerPanel.add(jTextField4);
			
			jLabel5.setText("级别");
			jLabel5.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=2;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel5, girdBagCon);
			centerPanel.add(jLabel5);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=2;
			girdBagCon.insets=new Insets(10, 1, 10, 15);
			girdBag.setConstraints(jTextField5, girdBagCon);
			centerPanel.add(jTextField5);
			
			jLabel6.setText("发表年份");
			jLabel6.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=4;
			girdBagCon.gridy=2;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 15, 10, 1);
			girdBag.setConstraints(jLabel6, girdBagCon);
			centerPanel.add(jLabel6);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=5;
			girdBagCon.gridy=2;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField6, girdBagCon);
			centerPanel.add(jTextField6);
			
			//第四行显示组件 gridy=4 gridx 依次增加
			jLabel7.setText("刊期");
			jLabel7.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=3;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel7, girdBagCon);
			centerPanel.add(jLabel7);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=3;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField7, girdBagCon);
			centerPanel.add(jTextField7);
			
			jLabel8.setText("字数");
			jLabel8.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=3;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel8, girdBagCon);
			centerPanel.add(jLabel8);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=3;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField8, girdBagCon);
			centerPanel.add(jTextField8);
			
			jLabel9.setText("所在系部");
			jLabel9.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=4;
			girdBagCon.gridy=3;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel9, girdBagCon);
			centerPanel.add(jLabel9);
			
			Department department=new Department();
			String[] s=department.searchAllForNode();
			//jComboBox12.setPreferredSize(new Dimension(125, 25));
			jComboBox12=new JComboBox(s);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=5;
			girdBagCon.gridy=3;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jComboBox12, girdBagCon);
			centerPanel.add(jComboBox12);
			
			jLabel10.setText("录入日期");
			jLabel10.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=4;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel10, girdBagCon);
			centerPanel.add(jLabel10);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=4;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField10, girdBagCon);
			centerPanel.add(jTextField10);
			
			
			jLabel11.setText("备注");
			jLabel11.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=4;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 1);
			girdBag.setConstraints(jLabel11, girdBagCon);
			centerPanel.add(jLabel11);
			
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=4;
			girdBagCon.insets=new Insets(10, 1, 10, 10);
			girdBag.setConstraints(jTextField11, girdBagCon);
			centerPanel.add(jTextField11);
			
			
			//定义部门操作类
			//DeptBean dBean=new DeptBean();
			//调用方法获取所有部门的字符串
			//String[] alltype=dBean.searchAllForNode();
			//jComboBox1=new JComboBox(alltype);
			
			//girdBagCon=new GridBagConstraints();
			//girdBagCon.gridx=1;
			//girdBagCon.gridy=4;
			//girdBagCon.gridwidth=3;
			//girdBagCon.gridheight=1;
			//girdBagCon.insets=new Insets(10, 1, 10, 15);
			//girdBag.setConstraints(jComboBox1, girdBagCon);
			//centerPanel.add(jComboBox1);
						
			hq.setText("获取新编号");
			hq.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=0;
			girdBagCon.gridy=5;
			girdBagCon.gridwidth=2;
			girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, 10);
			girdBag.setConstraints(hq, girdBagCon);
			centerPanel.add(hq);
			
			addInfo.setText("增加");
			addInfo.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=1;
			girdBagCon.gridy=5;
			girdBagCon.gridwidth=2;
			girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, -100);
			girdBag.setConstraints(addInfo, girdBagCon);
			centerPanel.add(addInfo);
			
			modifyInfo.setText("修改");
			modifyInfo.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=2;
			girdBagCon.gridy=5;
			//girdBagCon.gridwidth=2;
			//girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, -150);
			girdBag.setConstraints(modifyInfo, girdBagCon);
			centerPanel.add(modifyInfo);
			
			deleteInfo.setText("删除");
			deleteInfo.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=3;
			girdBagCon.gridy=5;
			//girdBagCon.gridwidth=2;
			//girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, -150);
			girdBag.setConstraints(deleteInfo, girdBagCon);
			centerPanel.add(deleteInfo);
			
			deleteInfo.addActionListener((ActionListener) this);
			
			
			clearInfo.setText("清空");
			clearInfo.setFont(new Font("Dialog", 0, 12));
			girdBagCon=new GridBagConstraints();
			girdBagCon.gridx=4;
			girdBagCon.gridy=5;
			//girdBagCon.gridwidth=2;
			//girdBagCon.gridheight=1;
			//外部填充 4个参数 top,left,bottom,right
			//既外部间距
			girdBagCon.insets=new Insets(10, 10, 10, -170);
			girdBag.setConstraints(clearInfo, girdBagCon);
			centerPanel.add(clearInfo);
			this.add(centerPanel,BorderLayout.CENTER);

			jTextField1.setEditable(false);
			deleteInfo.setEnabled(false);
			modifyInfo.setEnabled(false);
			addInfo.setEnabled(false);
		}
		
		public void addListener() throws Exception{
			//删除按钮 活动监听
			deleteInfo.addActionListener(this);
			hq.addActionListener(this);
			addInfo.addActionListener(this);
			modifyInfo.addActionListener(this);
			clearInfo.addActionListener(this);
			jComboBox11.addItemListener(this);
			jComboBox12.addItemListener(new ItemListener() {
				
				@Override
				public void itemStateChanged(ItemEvent e) {
					// TODO Auto-generated method stub
					if (e.getStateChange()==ItemEvent.SELECTED)
					{
						//获取选中项目值，得到的是一个“1-办公室-秘书室”这样的字符串 
						//字符串构成：部门编号-一级部门-二级部门 
						System.out.println("321");
						String temStr=""+e.getItem();
						//返回指定子字符串"-"在此字符串中第一次出现处的索引 
						int i=temStr.indexOf("-");
						 //取部门id子字符串，目的是取前面的部门编号 
						DeptID=temStr.substring(0,i);
					}
					
				}
			});
		}
		public void actionPerformed(ActionEvent e) {
			// TODO Auto-generated method stub
			Object obj=e.getSource();
			ArticleBean art=new ArticleBean();
			if (obj==hq) {
				jTextField1.setText(Integer.toString(art.getId()));
				jTextField2.setText("");
				jTextField4.setText("");
				jTextField5.setText("");
				jTextField6.setText("");
				jTextField7.setText("");
				jTextField8.setText("");
				jTextField10.setText("");
				jTextField11.setText("");
				addInfo.setEnabled(true);
				deleteInfo.setEnabled(false);
				modifyInfo.setEnabled(false);
			}
	
			else if(obj==clearInfo) {
				jTextField1.setText("");
				jTextField2.setText("");
				jTextField4.setText("");
				jTextField5.setText("");
				jTextField6.setText("");
				jTextField7.setText("");
				jTextField8.setText("");
				jTextField10.setText("");
				jTextField11.setText("");
				deleteInfo.setEnabled(false);
				modifyInfo.setEnabled(false);
			}
			else if (obj==deleteInfo) {
				ArticleBean articleBean=new ArticleBean();
				articleBean.delete(jTextField1.getText());
				Node11Panel node13Panel=new Node11Panel();
				KyMain.splitPane.setRightComponent(node13Panel);
			} 
			else if (obj==addInfo) {
				
				
				art.add(jTextField2.getText(),teacher, jTextField4.getText(), jTextField5.getText(), jTextField6.getText(), jTextField7.getText(), jTextField8.getText(),DeptID,jTextField10.getText(), jTextField11.getText());
				
				Node11Panel node13Panel=new Node11Panel();
				KyMain.splitPane.setRightComponent(node13Panel);
			}
			else if (obj==modifyInfo) {
				art.modify(jTextField1.getText(), jTextField2.getText(), teacher, jTextField4.getText(), jTextField5.getText(), jTextField6.getText(), jTextField7.getText(), jTextField8.getText(), DeptID, jTextField10.getText(), jTextField11.getText());
				Node11Panel node13Panel=new Node11Panel();
				KyMain.splitPane.setRightComponent(node13Panel);
			}
			
			
			
			
			
			
				//重新生成界面 目的是删除记录后 显示删除后的剩余记录
				
				jTable.revalidate();//重新布局
	}
	
		@Override
		public void valueChanged(ListSelectionEvent e) {
			// TODO Auto-generated method stub
			//获取表选中的行的索引号
			int[] selecteRow=jTable.getSelectedRows();
			int[] selecteCol=jTable.getSelectedColumns();
			//定义文本框的现实内容
			//既在上面显示人员表中选中一条记录 下面上颚文本框中分别年是该记录的
			for (int i = 0; i < selecteRow.length; i++) {
				for (int j = 0; j < selecteCol.length; j++) {
					jTextField1.setText(colValue[selecteRow[i]][0]);
					jTextField2.setText(colValue[selecteRow[i]][1]);
					jTextField4.setText(colValue[selecteRow[i]][3]);
					jTextField5.setText(colValue[selecteRow[i]][4]);
					jTextField6.setText(colValue[selecteRow[i]][5]);
					jTextField7.setText(colValue[selecteRow[i]][6]);
					jTextField8.setText(colValue[selecteRow[i]][7]);
					jTextField10.setText(colValue[selecteRow[i]][9]);
					jTextField11.setText(colValue[selecteRow[i]][10]);
				}
			}
			deleteInfo.setEnabled(true);
			modifyInfo.setEnabled(true);
			hq.setEnabled(true);
			
		}
		public void itemStateChanged(ItemEvent e) {
			// TODO Auto-generated method stub
			//ItemEvent--项目事件，例如下拉列表框中项被选定或取消选定的事件 
			//e.getStateChange()--表示选定或取消选定 
			//ItemEvent.SELECTED--表示选定 
			//ItemEvent.DESELECTED--表示取消选定 
			//如果在下拉列表框中选中一个部门 
			//TeacherBean teacherBean=new TeacherBean();
			if (e.getStateChange()==ItemEvent.SELECTED)
			{
				//获取选中项目值，得到的是一个“1-办公室-秘书室”这样的字符串 
				//字符串构成：部门编号-一级部门-二级部门 
				System.out.println("123");
				String temStr=""+e.getItem();
				//返回指定子字符串"-"在此字符串中第一次出现处的索引 
				int i=temStr.indexOf("-");
				 //取部门id子字符串，目的是取前面的部门编号 
				teacher=temStr.substring(0,i);
			}
		}
	
	}

构建联合查询语句用于查询三联表中的数据

Mon, 14 Aug 2017 22:16:11 +0800

sql="select *,teacher.teacherID as teacherName, "
						+ "department.depID as depName "
						+ "from teacher,article,department "
						+ "where teacher.teacherID=article.teacherID and department.depID=article.depID "
			
						+ "order by articleID";

executeQueryUnknown column 'admin' in 'where clause' 解决办法

Mon, 14 Aug 2017 15:32:00 +0800

这个错误困扰了我两天啊因为这个错误所以做登陆界面的时候不是用的数据库所以也不能做注册修改

其实原因很简单而我得找了好几个小时都没有解决在测试的时候发现传递数字的时候可以返回记录到的字符串

而传递单词却无法返回就提示报错我觉着是数据库字符类型设计错了还是怎么得了百思不得解

接下来说明解决方法：

“select * from user where userName"=admin;

select * from user where userName=123

其实是因为执行sql查询语句的时候userName的值是数字所以不用加单引号而admin是英文所以要加上单引号

正确的应该是这样

sql="select * from user where userName='"+field2+"'";

在查询的字符串左右加上英文单冒号 ' '即可

在有main函数的前提下 eclipse找不到主类解决办法

Sun, 13 Aug 2017 21:49:23 +0800

有时候在测试类的时候eclipse会莫名奇妙的提示找不到主类接下来分别有几种解决办法

1.在项目上右击> Builder Path -> Configure Build Path -> 选择Source面板再点Add Folder, 把源代码所在的包路径的上层目录加进来，而且如果你是把两个类写在一个文件里的话,你在右键选择Run As Java Appication 的时候,要把光标至于包括main方法的类上

2复制粘贴带main函数的类创建一个新的类把代码复制进去即可ok

3 直接重建Java项目

如果还是不行在命令管理器上测试java是否正常运行如果没有看一下环境变量是否错误或者重新安装

login登陆界面设计

Sun, 13 Aug 2017 12:51:02 +0800

package com.jnzyjsxy.test;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class login extends Frame implements ActionListener {
TextField txtName;
TextField txtPassword;
Label lblTitle,lblName,lblPassword;
Button btnSubmit;
Button btnReset;

JButton clearInfo=new JButton();
static //创建网格包布局对象
GridBagLayout girdBag=new GridBagLayout();
//创建网格包约束类变量
GridBagConstraints girdBagCon;
public login(){
super("登陆界面");
//lblTitle=new Label("请输入您的用户信息:");
lblName=new Label("用户名:");
txtName=new TextField(15);
txtName.setFont(new Font("Dialog", 0, 15));
lblPassword=new Label("密码:");
txtPassword=new TextField(15);
txtPassword.setFont(new Font("Dialog", 0, 15));
txtPassword.setEchoChar('*');
btnSubmit=new Button("提交");
btnReset=new Button("重置");
//lblName.setText("用户名");

lblName.setFont(new Font("Dialog", 0, 16));
girdBagCon=new GridBagConstraints();
girdBagCon.gridx=0;
girdBagCon.gridy=1;
//外部填充 4个参数 top,left,bottom,right
//既外部间距
girdBagCon.insets=new Insets(0, 10, 10, 1);
girdBag.setConstraints(lblName, girdBagCon);
this.add(lblName);

girdBagCon=new GridBagConstraints();
girdBagCon.gridx=1;
girdBagCon.gridy=1;
girdBagCon.insets=new Insets(0, 1, 10, 15);
girdBag.setConstraints(txtName, girdBagCon);
this.add(txtName);

//lblPassword.setText("");
lblPassword.setFont(new Font("Dialog", 0, 16));
girdBagCon=new GridBagConstraints();
girdBagCon.gridx=0;
girdBagCon.gridy=2;
//外部填充 4个参数 top,left,bottom,right
//既外部间距
girdBagCon.insets=new Insets(0, 15, 10, 1);
girdBag.setConstraints(lblPassword, girdBagCon);
this.add(lblPassword);

girdBagCon=new GridBagConstraints();
girdBagCon.gridx=1;
girdBagCon.gridy=2;
girdBagCon.insets=new Insets(0, 1, 10, 15);
girdBag.setConstraints(txtPassword, girdBagCon);
this.add(txtPassword);

//addInfo.setText("增加");
btnSubmit.setFont(new Font("Dialog", 0, 16));
girdBagCon=new GridBagConstraints();
girdBagCon.gridx=0;
girdBagCon.gridy=3;
girdBagCon.gridwidth=2;
girdBagCon.gridheight=1;
//外部填充 4个参数 top,left,bottom,right
//既外部间距
girdBagCon.insets=new Insets(10, 10, 10, 90);
girdBag.setConstraints(btnSubmit, girdBagCon);
this.add(btnSubmit);

//clearInfo.setText("清空");
btnReset.setFont(new Font("Dialog", 0, 16));
girdBagCon=new GridBagConstraints();
girdBagCon.gridx=1;
girdBagCon.gridy=3;
girdBagCon.gridwidth=2;
girdBagCon.gridheight=1;
//外部填充 4个参数 top,left,bottom,right
//既外部间距
girdBagCon.insets=new Insets(10, 10, 10, -30);
girdBag.setConstraints(btnReset, girdBagCon);
this.add(btnReset);

this.btnSubmit.addActionListener(this);
this.btnReset.addActionListener(this);
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public void actionPerformed(ActionEvent e){
String s=e.getActionCommand();
if(s.equals("重置")){
clear();
}else if(s.equals("提交")){
submit();
}else if(e.getSource()==txtName){
txtPassword.requestFocus();
}else if(e.getSource()==txtPassword){
submit();
}
}
public void clear(){
txtName.setText("");
txtPassword.setText("");
txtName.requestFocus();
}
public void submit(){
String n=txtName.getText();
String paw=txtPassword.getText();
if(n.equals("admin") && paw.equals("123")){
JOptionPane.showMessageDialog(this,"合法用户，欢迎进入本系统");
	HrP hrP=new HrP();
}else{
	
		JOptionPane.showMessageDialog(this, "非法用户，禁止进入本系统");
		System.exit(0);
		

}
}
public static void main(String[] args) {
	try {
		//UIManager--界面管理类
		//外观设置成所使用的操作平台的外观
		//即程序在哪个平台运行，显示的窗口，对话框将是哪个平台的外观
		UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		login ttf=new login();
		ttf.setSize(300,200);
		//获取屏幕大小
				Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
				//获取当前项目的窗体大小
				Dimension frameSize=ttf.getSize();
				//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
				if (frameSize.height>screenSize.height) {
					frameSize.height=screenSize.height;
				}
				if (frameSize.width>screenSize.width) {
					frameSize.width=screenSize.width;
				}
		ttf.setLocation((screenSize.width-frameSize.width)/2,
				(screenSize.height-frameSize.height)/2);;
		ttf.setLayout(girdBag);
		 ttf.setResizable(false);
		ttf.setVisible(true);
		
	} catch (Exception e) {
		// TODO: handle exception
		e.printStackTrace();
	}
	//创建主类对象测试项目
	new login();

}

}

The project: Java which is referenced by the classpath, does not exist. 错误处理办法

Sat, 12 Aug 2017 21:18:29 +0800

在property-java build path-> project s tab把依赖去掉

转载自【 Java编程精选】深入理解 Java final 变量的内存模型

Fri, 11 Aug 2017 22:11:15 +0800

对于 final 域，编译器和处理器要遵守两个重排序规则：

在构造函数内对一个 final 域的写，与随后把这个构造对象的引用赋值给一个变量，这两个操作之间不能重排序
初次读一个包含 final 域的对象的引用，与随后初次读这个 final 域，这两个操作之间不能重排序

举个例子：

public class FinalExample {

int i;// 普通变量

final int j;// final 变量

static FinalExample obj;

public FinalExample() {

i = 1;// 写普通域

j = 2;// 写 final 域

}

public static void writer() {// 写线程 A 执行

obj = new FinalExample();

}

public static void reader() {// 读线程 B 执行

FinalExample object = obj;

int a = object.i;

int b = object.j;

}

这里假设一个线程 A 执行 writer ()方法,随后另一个线程 B 执行 reader ()方法。

转载自【 Java编程精选】SpringBoot(二) ：web综合开发

Fri, 11 Aug 2017 21:09:16 +0800

上篇文章介绍了Spring boot初级教程：spring boot(一)：入门篇，方便大家快速入门、了解实践Spring boot特性；本篇文章接着上篇内容继续为大家介绍spring boot的其它特性（有些未必是spring boot体系桟的功能，但是是spring特别推荐的一些开源技术本文也会介绍），对了这里只是一个大概的介绍，特别详细的使用我们会在其它的文章中来展开说明。

web开发

spring boot web开发非常的简单，其中包括常用的json输出、filters、property、log等

json 接口开发

在以前的spring 开发的时候需要我们提供json接口的时候需要做那些配置呢

添加 jackjson 等相关jar包
配置spring controller扫描
对接的方法添加@ResponseBody

就这样我们会经常由于配置错误，导致406错误等等，spring boot如何做呢，只需要类添加 @RestController 即可，默认类中的方法都会以json的格式返回

@RestController

public class HelloWorldController {

@RequestMapping("/getUser")

public User getUser() {

User user=new User();

user.setUserName("小明");

user.setPassWord("xxxx");

return user;

}

如果我们需要使用页面开发只要使用 @Controller ，下面会结合模板来说明

自定义Filter

我们常常在项目中会使用filters用于录调用日志、排除有XSS威胁的字符、执行权限验证等等。Spring Boot自动添加了OrderedCharacterEncodingFilter和HiddenHttpMethodFilter，并且我们可以自定义Filter。

两个步骤：

实现Filter接口，实现Filter方法
添加@Configurationz 注解，将自定义Filter加入过滤链

好吧，直接上代码

@Configuration

public class WebConfiguration {

@Bean

public RemoteIpFilter remoteIpFilter() {

return new RemoteIpFilter();

}

@Bean

public FilterRegistrationBean testFilterRegistration() {

FilterRegistrationBean registration = new FilterRegistrationBean();

registration.setFilter(new MyFilter());

registration.addUrlPatterns("/*");

registration.addInitParameter("paramName", "paramValue");

registration.setName("MyFilter");

registration.setOrder(1);

return registration;

}

public class MyFilter implements Filter {

@Override

public void destroy() {

// TODO Auto-generated method stub

}

@Override

public void doFilter(ServletRequest srequest, ServletResponse sresponse, FilterChain filterChain)

throws IOException, ServletException {

// TODO Auto-generated method stub

HttpServletRequest request = (HttpServletRequest) srequest;

System.out.println("this is MyFilter,url :"+request.getRequestURI());

filterChain.doFilter(srequest, sresponse);

}

@Override

public void init(FilterConfig arg0) throws ServletException {

// TODO Auto-generated method stub

}

自定义Property

在web开发的过程中，我经常需要自定义一些配置文件，如何使用呢

转载自【 Java编程精选】SpringBoot (一) ：入门篇

Fri, 11 Aug 2017 20:08:20 +0800

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。用我的话来理解，就是spring boot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了所有的框架（不知道这样比喻是否合适）。

使用spring boot有什么好处
1）配置web.xml，加载spring和spring mvc
2）配置数据库连接、配置spring事务
3）配置加载配置文件的读取，开启注解
4）配置日志文件
…
配置完成之后部署tomcat 调试
…
现在非常流行微服务，如果我这个项目仅仅只是需要发送一个邮件，如果我的项目仅仅是生产一个积分；我都需要这样折腾一遍!
但是如果使用spring boot呢？
很简单，我仅仅只需要非常少的几个配置就可以迅速方便的搭建起来一套web项目或者是构建一个微服务！
快速入门
maven构建项目
1、访问https://start.spring.io/
2、选择构建工具Maven Project、Spring Boot版本1.3.6以及一些工程基本信息，点击“Switch to the full version.”java版本选择1.7，可参考下图所示：
3、点击Generate Project下载项目压缩包
4、解压后，使用eclipse，Import -> Existing Maven Projects -> Next ->选择解压后的文件夹-> Finsh，OK done!
项目结构介绍
另外，spingboot建议的目录结果如下：
root package结构：com.example.myproject

com

+- example

+- myproject

+- Application.java

|

+- domain

| +- Customer.java

| +- CustomerRepository.java

|

+- service

| +- CustomerService.java

|

+- controller

| +- CustomerController.java

|

1、Application.java 建议放到根目录下面,主要用于做一些框架配置
2、domain目录主要用于实体（Entity）与数据访问层（Repository）
3、service 层主要是业务类代码
4、controller 负责页面访问控制
采用默认配置可以省去很多配置，当然也可以根据自己的喜欢来进行更改
最后，启动Application main方法，至此一个java项目搭建好了！
引入web模块

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

@RestController

public class HelloWorldController {

@RequestMapping("/hello")

public String index() {

return "Hello World";

}

@RunWith(SpringJUnit4ClassRunner.class)

@SpringApplicationConfiguration(classes = MockServletContext.class)

@WebAppConfiguration

public class HelloWorldControlerTests {

private MockMvc mvc;

@Before

public void setUp() throws Exception {

mvc = MockMvcBuilders.standaloneSetup(new HelloWorldController()).build();

}

@Test

public void getHello() throws Exception {

mvc.perform(MockMvcRequestBuilders.get("/hello").accept(MediaType.APPLICATION_JSON))

.andExpect(MockMvcResultMatchers.status().isOk())

.andDo(MockMvcResultHandlers.print())

.andReturn();

}

开发环境的调试

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

<optional>true</optional>

</dependency>

</dependencies>

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

<configuration>

<fork>true</fork>

</configuration>

</plugin>

</plugins>

</build>

总结

关于 JCombobox

Wed, 09 Aug 2017 21:42:14 +0800

构造函数

JComboBox()
          创建具有默认数据模型的 JComboBox。
JComboBox(ComboBoxModel aModel)
          创建一个 JComboBox，其项取自现有的 ComboBoxModel 中。
JComboBox(Object[] items)
          创建包含指定数组中的元素的 JComboBox。
JComboBox(Vector<?> items)
          创建包含指定 Vector 中的元素的 JComboBox。

常用方法
addActionListener(ActionListener l)
          添加 ActionListener。
addItem(Object anObject)
          为项列表添加项。
addItemListener(ItemListener aListener)
          添加 ItemListener。
configureEditor(ComboBoxEditor anEditor, Object anItem)
          利用指定项初始化编辑器。
getEditor()
          返回用于绘制和编辑 JComboBox 字段中所选项的编辑器。
getItemAt(int index)
          返回指定索引处的列表项。
getItemCount()
          返回列表中的项数。
getModel()
          返回 JComboBox 当前使用的数据模型。
getRenderer()
          返回用于显示 JComboBox 字段中所选项的渲染器。
getSelectedIndex()
          返回列表中与给定项匹配的第一个选项。
getSelectedItem()
          返回当前所选项。
insertItemAt(Object anObject, int index)
          在项列表中的给定索引处插入项。
isEditable()
          如果 JComboBox 可编辑，则返回 true。
removeAllItems()
          从项列表中移除所有项。
removeItem(Object anObject)
          从项列表中移除项。
removeItemAt(int anIndex)
          移除 anIndex 处的项。
setModel(ComboBoxModel aModel)
          设置 JComboBox 用于获取项列表的数据模型。
setRenderer(ListCellRenderer aRenderer)
          设置渲染器，该渲染器用于绘制列表项和从 JComboBox 字段的列表中选择的项。
setSelectedIndex(int anIndex)
          选择索引 anIndex 处的项。
setSelectedItem(Object anObject)
          将组合框显示区域中所选项设置为参数中的对象

Node11Panel类添加人员信息操作

Tue, 08 Aug 2017 19:16:47 +0800

package com.jnzyjsxy.node1;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;

import com.jnzyjsxy.common.DeptBean;
import com.jnzyjsxy.common.PersonBean;
import com.jnzyjsxy.test.HrMain;

/*
 * 第一个节点
 * 添加人员信息
 */
public class Node11Panel extends JPanel implements ActionListener,ItemListener{
	
	//创建两个面板 一个中间面板 一个上部面板
	JPanel centerPanel=new JPanel();
	JPanel upPanel=new JPanel();
	//定义图形元素
	JLabel jLabel = new JLabel();
	JLabel jLabel1 = new JLabel();
	JLabel jLabel2 = new JLabel();
	JLabel jLabel3 = new JLabel();
	JLabel jLabel4 = new JLabel();
	JLabel jLabel5 = new JLabel();
	JLabel jLabel6 = new JLabel();
	JLabel jLabel7 = new JLabel();
	JLabel jLabel8 = new JLabel();
	JLabel jLabel9 = new JLabel();
	
	JTextField jTextField1 =new JTextField(15);//编号
	JTextField jTextField2 =new JTextField(15);//姓名
	JTextField jTextField3 =new JTextField(15);//性别
	JTextField jTextField4 =new JTextField(15);//出生年月
	JTextField jTextField5 =new JTextField(15);//民族
	JTextField jTextField6 =new JTextField(15);//地址
	
	JComboBox jComboBox1=null;//显示人员所在部门
	String DeptID="1";//部门编号
	String Salary="0";//薪酬
	String Assess="未考核";//考核
	//用于输入其他字段值
	JTextField jTextField8=new JTextField(15);
	
	JScrollPane jScrollPane;
	//创建按钮 本页面使用addInfo clearInfo 
	//为了实现页面复制 定义多个按钮 哪个页面需要 使用哪个按钮
	JButton addInfo=new JButton();
	JButton modifyInfo=new JButton();
	JButton deleteInfo=new JButton();
	JButton clearInfo=new JButton();
	//创建网格包布局对象
	GridBagLayout girdBag=new GridBagLayout();
	//创建网格包约束类变量
	GridBagConstraints girdBagCon;
	//创建PersonBean 人员数据操作类
	PersonBean bean=new PersonBean();
	
	public Node11Panel() {
		// TODO Auto-generated constructor stub
		//采用边框布局
		this.setLayout(new BorderLayout());
		try {
			jscrollPanelInit();//上部面板初始
			panelInit();//中间面板初始化
			addListener();//监听事件方法
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	/*
	 * jscrollpanel 面板的布局 包含放置组件的中间面板centerPanel
	 * (non-Javadoc)
	 * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
	 */
	public void jscrollPanelInit() {
		//中间放组件的面板 采用网格包布局
		centerPanel.setLayout(girdBag);
		//第一行组件
		//griy=1 实际的第二行 显示4个组件 gridx依次增加
		jLabel1.setText("人员编号");
		jLabel1.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 10, 10, 1);
		girdBag.setConstraints(jLabel1, girdBagCon);
		centerPanel.add(jLabel1);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=1;
		girdBagCon.gridy=1;
		girdBagCon.insets=new Insets(0, 1, 10, 15);
		girdBag.setConstraints(jTextField1, girdBagCon);
		centerPanel.add(jTextField1);
		
		jLabel2.setText("人员姓名");
		jLabel2.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 15, 10, 1);
		girdBag.setConstraints(jLabel2, girdBagCon);
		centerPanel.add(jLabel2);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=3;
		girdBagCon.gridy=1;
		girdBagCon.insets=new Insets(0, 1, 10, 10);
		girdBag.setConstraints(jTextField2, girdBagCon);
		centerPanel.add(jTextField2);
		
		jLabel3.setText("性 别");
		jLabel3.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=2;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 1);
		girdBag.setConstraints(jLabel3, girdBagCon);
		centerPanel.add(jLabel3);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=1;
		girdBagCon.gridy=2;
		girdBagCon.insets=new Insets(10, 1, 10, 15);
		girdBag.setConstraints(jTextField3, girdBagCon);
		centerPanel.add(jTextField3);
		
		jLabel4.setText("出 生 年 月");
		jLabel4.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=2;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 15, 10, 1);
		girdBag.setConstraints(jLabel4, girdBagCon);
		centerPanel.add(jLabel4);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=3;
		girdBagCon.gridy=2;
		girdBagCon.insets=new Insets(10, 1, 10, 10);
		girdBag.setConstraints(jTextField4, girdBagCon);
		centerPanel.add(jTextField4);
		
		jLabel5.setText("民		族");
		jLabel5.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=3;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 1);
		girdBag.setConstraints(jLabel5, girdBagCon);
		centerPanel.add(jLabel5);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=1;
		girdBagCon.gridy=3;
		girdBagCon.insets=new Insets(10, 1, 10, 15);
		girdBag.setConstraints(jTextField5, girdBagCon);
		centerPanel.add(jTextField5);
		
		jLabel6.setText("地		址");
		jLabel6.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=3;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 15, 10, 1);
		girdBag.setConstraints(jLabel6, girdBagCon);
		centerPanel.add(jLabel6);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=3;
		girdBagCon.gridy=3;
		girdBagCon.insets=new Insets(10, 1, 10, 10);
		girdBag.setConstraints(jTextField6, girdBagCon);
		centerPanel.add(jTextField6);
		
		//第四行显示组件 gridy=4 gridx 依次增加
		jLabel7.setText("部		门");
		jLabel7.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=4;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 1);
		girdBag.setConstraints(jLabel7, girdBagCon);
		centerPanel.add(jLabel7);
		
		//定义部门操作类
		DeptBean dBean=new DeptBean();
		//调用方法获取所有部门的字符串
		String[] alltype=dBean.searchAllForNode();
		jComboBox1=new JComboBox(alltype);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=1;
		girdBagCon.gridy=4;
		//girdBagCon.gridwidth=3;
		//girdBagCon.gridheight=1;
		girdBagCon.insets=new Insets(10, 1, 10, 15);
		girdBag.setConstraints(jComboBox1, girdBagCon);
		centerPanel.add(jComboBox1);
				
		jLabel8.setText("其		他");
		jLabel8.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=4;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 0, 10, 1);
		girdBag.setConstraints(jLabel8, girdBagCon);
		centerPanel.add(jLabel8);
		
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=3;
		girdBagCon.gridy=4;
		girdBagCon.gridwidth=3;
		girdBagCon.gridheight=1;
		girdBagCon.insets=new Insets(10, 1, 10, 15);
		girdBag.setConstraints(jTextField8, girdBagCon);
		centerPanel.add(jTextField8);
		
		addInfo.setText("增加");
		addInfo.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=5;
		girdBagCon.gridwidth=2;
		girdBagCon.gridheight=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 10);
		girdBag.setConstraints(addInfo, girdBagCon);
		centerPanel.add(addInfo);
		
		
		
		clearInfo.setText("清空");
		clearInfo.setFont(new Font("Dialog", 0, 12));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=2;
		girdBagCon.gridy=5;
		girdBagCon.gridwidth=2;
		girdBagCon.gridheight=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(10, 10, 10, 10);
		girdBag.setConstraints(clearInfo, girdBagCon);
		centerPanel.add(clearInfo);

	}
	
	//上部面板初始化
	public void panelInit() {
		//上部面板，网格包布局
		upPanel.setLayout(girdBag);
		//上部包含泽增加人员信息标签和滚动面板
		jLabel.setText("增加人员信息");
		jLabel.setFont(new Font("Dialog", 0, 16));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=0;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 10, 0, 10);
		girdBag.setConstraints(jLabel, girdBagCon);
		upPanel.add(jLabel);
		
		//滚动面板 包含组件的中间，面板在滚动面板上
		jScrollPane =new JScrollPane(centerPanel);
		jScrollPane.setPreferredSize(new Dimension(450,380));
		girdBagCon=new GridBagConstraints();
		girdBagCon.gridx=0;
		girdBagCon.gridy=1;
		//外部填充 4个参数 top,left,bottom,right
		//既外部间距
		girdBagCon.insets=new Insets(0, 0, 0, 0);
		girdBag.setConstraints(jScrollPane, girdBagCon);
		upPanel.add(jScrollPane);
		
		//上部面板添加到窗体
		this.add(upPanel,BorderLayout.NORTH);
		//设置人员编号文本框不可用
		jTextField1.setEditable(false);
		jTextField2.setEditable(true);
		jTextField3.setEditable(true);
		jTextField4.setEditable(true);
		jTextField5.setEditable(true);
		jTextField6.setEditable(true);
		jTextField8.setEditable(true);
		jTextField1.setText(""+bean.getId());
		
	}
	/*添加事件监听
	 * (non-Javadoc)
	 * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
	 */
	public void addListener() {
		//添加添加，清空按钮事件监听
		addInfo.addActionListener(this);
		clearInfo.addActionListener(this);
		//给显示部门的下拉列表添加项目选择监听
		//既当在下拉列表框中选择项目后 触发监听
		jComboBox1.addItemListener(this);
		
	}
	@Override
	public void itemStateChanged(ItemEvent e) {
		// TODO Auto-generated method stub
		//ItemEvent--项目事件，例如下拉列表框中项被选定或取消选定的事件 
		//e.getStateChange()--表示选定或取消选定 
		//ItemEvent.SELECTED--表示选定 
		//ItemEvent.DESELECTED--表示取消选定 
		//如果在下拉列表框中选中一个部门 
		if (e.getStateChange()==ItemEvent.SELECTED) {
			//获取选中项目值，得到的是一个“1-办公室-秘书室”这样的字符串 
			//字符串构成：部门编号-一级部门-二级部门 
			String temStr=""+e.getItem();
			//返回指定子字符串"-"在此字符串中第一次出现处的索引 
			int i=temStr.indexOf("-");
			 //取部门id子字符串，目的是取前面的部门编号 
			DeptID=temStr.substring(0,i);
		}
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object obj=e.getSource();
		if (obj==addInfo) {//增加
			//调用Personean的add()方法 实现添加纪录
			bean.add(jTextField1.getText(), jTextField2.getText(), jTextField3.getText(), jTextField4.getText(), jTextField5.getText(), jTextField6.getText(), DeptID, Salary, Assess, jTextField8.getText());
			//定义添加人员信息页面对象
			Node11Panel node11Panel=new Node11Panel();
			//用添加人员信息作为右侧组件
			HrMain.splitPane.setRightComponent(node11Panel);
		}
		else if (obj==clearInfo) {
			setNull();//调用清空方法
		}
	}
	void setNull(){
		jTextField2.setText(null);
		jTextField3.setText(null);
		jTextField4.setText(null);
		jTextField5.setText(null);
		jTextField6.setText(null);
		jTextField8.setText(null);
	}

}

系统运行主类HrP.java（包含main）和主界面类HrMain.java 1. 系统运行主类HrMS.java，包含main方法。

Tue, 08 Aug 2017 19:16:10 +0800

package com.jnzyjsxy.test;

import java.awt.Dimension;
import java.awt.Toolkit;

import javax.swing.UIManager;

/*
 * 人事管理运行主类
 */
public class HrP {
	//定义布尔型变量
	boolean packFame=false;
	//构造方法
	public HrP() {
		// TODO Auto-generated constructor stub
		//创建主窗体类对象
		HrMain frame=new HrMain();
		if (packFame) {
			//窗口自适应大小 使窗口正好显示里面的控件
			frame.pack();
		}else {
			//使用validate方法 会使容器再次布置其子控件
			frame.validate();
		}
		//获取屏幕大小
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		//获取当前项目的窗体大小
		Dimension frameSize=frame.getSize();
		//如果项目窗体高>屏幕高，用屏幕高设置项目窗体高
		if (frameSize.height>screenSize.height) {
			frameSize.height=screenSize.height;
		}
		if (frameSize.width>screenSize.width) {
			frameSize.width=screenSize.width;
		}
		//设置窗体起始显示位置 居中显示
		frame.setLocation((screenSize.width-frameSize.width)/2,
		(screenSize.height-frameSize.height)/2);
		//显示窗体
		frame.setVisible(true);
	}
	public static void main(String[] args) {
		 //设置运行风格
		try {
			//UIManager--界面管理类
			//外观设置成所使用的操作平台的外观
			//即程序在哪个平台运行，显示的窗口，对话框将是哪个平台的外观
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		//创建主类对象测试项目
		new HrP();
	}
}

HrMain.java系统主界面类，采用树形目录结构。

Tue, 08 Aug 2017 19:14:37 +0800

package com.jnzyjsxy.test;
import java.awt.AWTError;
import java.awt.AWTEvent;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Panel;
import java.awt.Toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.net.URL;
import java.net.URLClassLoader;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
/*

人事管理系统主界面
*/
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import com.jnzyjsxy.node1.Node11Panel;
public class HrMain extends JFrame implements TreeSelectionListener{
private static final URLClassLoader URLClassLoader = null;
//框架大小
Dimension faceSize=new Dimension(650, 450);
//程序图标
Image icon;
//建立JTree目录树对象
JTree tree;
//书数据结构中的通用节点
//字面含义，默认可变的树节点类
DefaultMutableTreeNode root;//人事管理系统根节点
DefaultMutableTreeNode node1;//基本信息管理
DefaultMutableTreeNode node2;//人员管理节点
DefaultMutableTreeNode node3;//人员考核管理
DefaultMutableTreeNode node4;//劳资管理
DefaultMutableTreeNode node5;//
DefaultMutableTreeNode leafnode;//二级节点
TreePath treePath;//节点路径类
//主界面面板
//JSplitPane 用于分割两个（只能是两个）Component
//两个Component图形化分割
//并且这两个Component可以由用户交互式调整大小
//split–分裂，拆分
public static JSplitPane splitPane;
JPanel panel1;//在左侧放目录树
JPanel panel2;
JPanel panel3;//在右侧显示选择节点后的界面
//用于显示欢迎信息的标签
JLabel welcome=new JLabel();
//滚动面板对象
JScrollPane scrollPane;
/*
* 构造方法(non-Javadoc)
* @see java.awt.Window#pack()
/public HrMain() {
// TODO Auto-generated constructor stub
//启动窗体事件隐藏 mask-面具，隐藏
//要是没有enableEvents(AWTEvent.WIDOW_EVENT_MASK);
//只要有addActionListener()方法，窗体也就拥有该方法
//本项目通过选择目录树触发活动事件
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
//添加框架的关闭时间处理
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//窗口自适应大小 使窗体能正好显示里面的所有控件
this.pack();
//设置框架的大小
this.setSize(faceSize);
//设置窗体的标题
this.setTitle(“人事管理系统”);
//调用自定义的方法GetImage（） ，获取图标文件
//icon=getImage(“common/icon.png”);
//设置窗体图标
this.setIconImage(icon);
//设置不能调整窗体的大小
this.setResizable(false);
try {
Init();//调用初始化方法
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
/
* 初始化方法 创建左侧菜单树
*/
private void Init() {
// TODO Auto-generated method stub
//初始化树形节点
root=new DefaultMutableTreeNode(“人事管理系统”);
node1=new DefaultMutableTreeNode(“基本信息管理”);
node2=new DefaultMutableTreeNode(“人员调动管理”);
node3=new DefaultMutableTreeNode(“人员考核管理”);
node4=new DefaultMutableTreeNode(“劳资管理”);
//添加基本信息管理节点到认识管里系统根节点
root.add(node1);
//添加耳机节点 并添加到基本信息管理一级节点上
leafnode=new DefaultMutableTreeNode(“添加人员信息”);
node1.add(leafnode);
leafnode=new DefaultMutableTreeNode(“修改人员信息”);
node1.add(leafnode);
leafnode=new DefaultMutableTreeNode(“删除人员信息”);
node1.add(leafnode);
leafnode=new DefaultMutableTreeNode(“查询人员信息”);
node1.add(leafnode);
leafnode=new DefaultMutableTreeNode(“部门管理”);
node1.add(leafnode);
//添加人员调动节点到根节点
root.add(node2);
leafnode=new DefaultMutableTreeNode(“人员调动”);
node2.add(leafnode);
leafnode=new DefaultMutableTreeNode(“调动历史查询”);
node2.add(leafnode);
root.add(node3);
leafnode=new DefaultMutableTreeNode(“人员考核”);
node3.add(leafnode);
leafnode=new DefaultMutableTreeNode(“考核历史查询”);
node3.add(leafnode);

HistrinBean.java 类，用亍实现对历史流水相关信息进行数据库操作的功能，包括增加流水信息、提供多种方式的查询等

Tue, 08 Aug 2017 19:11:26 +0800

package com.jnzyjsxy.common;

import java.sql.ResultSet;

import javax.swing.JOptionPane;

public class HistrinBean {
	//定义字符串用于存储sql字符串
		String sql;
		//结果集类
		ResultSet rs=null;
		//声明字符串变量 存储从操作界面传过来的人员信息
		String field1;
		String field2;
		String field3;
		String field4;
		String field5;
		String field6;
		String field7;
		public void add(String f1,String f2,String f3,String f4,String f5,
				String f6,String f7){
			//创建数据库对象 执行数据库里面的方法 链接数据库 执行sql语句
			Database DB=new Database();
			//将从添加界面传过来的值 付给成员变量
			this.field1=f1;
			this.field2=f2;
			this.field3=f3;
			this.field4=f4;
			this.field5=f5;
			this.field6=f6;
			this.field7=f7;
			//判断穿过来的值是否为空 如果为空就显示提示语句
			if (field2==null || field2.equals("")) {
				JOptionPane.showMessageDialog(null, "请输入FromAcc", "错误", JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field3==null||field3.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入OldInfo","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field4==null||field4.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入NewInfo","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field5==null||field5.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入ChgTime","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field6==null||field6.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入RegDate","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field7==null||field7.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入PersonID","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			//构建插入字符串
			//构建sql字符串时，注意字符型，两侧用单引号做定界符，int,float不用定界符
			//传递过来的数据是字符型， 
			//为了插入int数据，进行类型转换-Integer.parseInt(field1)
			else {
				sql="insert into Histrjn( b,PersonID) values("+Integer.parseInt(field1)+ ",'"+field2+"','"+field3+"','"+field4+"',"+Integer.parseInt(field5)+",'"+field6+"',"+Integer.parseInt(field7)+")";
				System.out.println(sql);	
				//打开数据库连接
				try {
					DB.openConn();
					//执行sql语句
					DB.executeUpdate(sql);
					//提示信息
					JOptionPane.showMessageDialog(null, "你成功添加一条新的纪录");
				} catch (Exception e) {
					// TODO: handle exception
					//出现异常 ，给出提示
					System.out.println(e);
					JOptionPane.showMessageDialog(null, "保存失败 ","错误！", JOptionPane.ERROR_MESSAGE);
				}
					//关闭语句对象和链接对象
					finally{
						DB.closeStmt();
						DB.closeConn();
					}
				}
		}
			/*
			 * 根据JourNo
			 * ，返回人员信息各列值组成的字符数组
			 */
			public String[] search(String f1) {
				Database DB=new Database();
				this.field1=f1;
				//创建字符串数组 用于记录查询的数据
				String[] s =new String[6];
				sql="select * from Histrjn where JourNo="+field1;
				try{
					DB.openConn();//连接数据库
					//执行查询，查询结果付给rs，rs为结果集
					rs=DB.executeQuery(sql);
					//如果rs.next为true
					if (rs.next()) {
						//获取指定的值
						//说明：PersonID'DeptId salary均不是String类型
						//但在此简化处理，把取出值看作字符串，赋值给字符数组元素
						//方便统一待会返回值
						s[0]=rs.getString("JourNo");
						s[1]=rs.getString("FromAcc");
						s[2]=rs.getString("OldInfo");
						s[3]=rs.getString("NewInfo");
						s[4]=rs.getString("ChgTime");
						s[5]=rs.getString("RegDate");
						s[6]=rs.getString("PersonID");
					}else {
						s=null;
					}
				}catch(Exception e){
					
				}finally {
						DB.closeStmt();
						DB.closeConn();
					}
				return s;
				}
			/*
			 * 根据PersonID
			 * ，返回人员信息各列值组成的字符数组
			 */
			public String[] searchPI(String f7) {
				Database DB=new Database();
				this.field1=f7;
				//创建字符串数组 用于记录查询的数据
				String[] s =new String[6];
				sql="select * from Histrjn where PersonID="+field7;
				try{
					DB.openConn();//连接数据库
					//执行查询，查询结果付给rs，rs为结果集
					rs=DB.executeQuery(sql);
					//如果rs.next为true
					if (rs.next()) {
						//获取指定的值
						//说明：PersonID'DeptId salary均不是String类型
						//但在此简化处理，把取出值看作字符串，赋值给字符数组元素
						//方便统一待会返回值
						s[0]=rs.getString("JourNo");
						s[1]=rs.getString("FromAcc");
						s[2]=rs.getString("OldInfo");
						s[3]=rs.getString("NewInfo");
						s[4]=rs.getString("ChgTime");
						s[5]=rs.getString("RegDate");
						s[6]=rs.getString("PersonID");
					}else {
						s=null;
					}
				}catch(Exception e){
					
				}finally {
						DB.closeStmt();
						DB.closeConn();
					}
				return s;
				}
			}

外观设置成所使用的操作平台的外观即程序在哪个平台运行，显示的窗口，对话框将是哪个平台的外观

Mon, 07 Aug 2017 18:57:57 +0800

 //UIManager--界面管理类
			//外观设置成所使用的操作平台的外观
			//即程序在哪个平台运行，显示的窗口，对话框将是哪个平台的外观
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

用于测试数据库连接情况

Mon, 07 Aug 2017 13:41:34 +0800

package com.jnzyjsxy.test;

import com.jnzyjsxy.common.Database;
import com.jnzyjsxy.common.DeptBean;
import com.jnzyjsxy.common.HistrinBean;
import com.jnzyjsxy.common.PersonBean;

public class Text {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//PersonBean personBean=new PersonBean();
		//personBean.add("7","庞玉栋", "男", "1998-1-19", "汉", "", "7", "1900.23", "优秀",null);
		//personBean.updateDept("5", "2000.0");
		//String[][] strings=personBean.searchAll();
		//System.out.println(strings[0][2]);
		//String f1 = "1";
		//personBean.delete(f1);
		//DeptBean deptBean=new DeptBean();
		//String[] strings=deptBean.search("7");
		//System.out.print(strings[0]+".");
		//System.out.print(strings[1]+".");
		//System.out.print(strings[2]);
		//System.out.println(deptBean.getDepstr("1"));
		HistrinBean histrinBean=new HistrinBean();
		String[] string=null;
		//histrinBean.add("13", "人员分配", "2", "4", "1", "1", "1");
		string=histrinBean.search("1");
		System.out.println(string[4]);
	}
	

}

人事管理系统——Histrjn表增删改查操作类

Mon, 07 Aug 2017 13:37:08 +0800

package com.jnzyjsxy.common;

import java.sql.ResultSet;

import javax.swing.JOptionPane;

public class HistrinBean {
	//定义字符串用于存储sql字符串
		String sql;
		//结果集类
		ResultSet rs=null;
		//声明字符串变量 存储从操作界面传过来的人员信息
		String field1;
		String field2;
		String field3;
		String field4;
		String field5;
		String field6;
		String field7;
		public void add(String f1,String f2,String f3,String f4,String f5,
				String f6,String f7){
			//创建数据库对象 执行数据库里面的方法 链接数据库 执行sql语句
			Database DB=new Database();
			//将从添加界面传过来的值 付给成员变量
			this.field1=f1;
			this.field2=f2;
			this.field3=f3;
			this.field4=f4;
			this.field5=f5;
			this.field6=f6;
			this.field7=f7;
			//判断穿过来的值是否为空 如果为空就显示提示语句
			if (field2==null || field2.equals("")) {
				JOptionPane.showMessageDialog(null, "请输入FromAcc", "错误", JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field3==null||field3.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入OldInfo","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field4==null||field4.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入NewInfo","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field5==null||field5.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入ChgTime","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field6==null||field6.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入RegDate","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			else if (field7==null||field7.equals("")) {
				JOptionPane.showMessageDialog(null,"请输入PersonID","错误",
						JOptionPane.ERROR_MESSAGE);
				return;
			}
			//构建插入字符串
			//构建sql字符串时，注意字符型，两侧用单引号做定界符，int,float不用定界符
			//传递过来的数据是字符型， 
			//为了插入int数据，进行类型转换-Integer.parseInt(field1)
			else {
				sql="insert into Histrjn( b,PersonID) values("+Integer.parseInt(field1)+ ",'"+field2+"','"+field3+"','"+field4+"',"+Integer.parseInt(field5)+",'"+field6+"',"+Integer.parseInt(field7)+")";
				System.out.println(sql);	
				//打开数据库连接
				try {
					DB.openConn();
					//执行sql语句
					DB.executeUpdate(sql);
					//提示信息
					JOptionPane.showMessageDialog(null, "你成功添加一条新的纪录");
				} catch (Exception e) {
					// TODO: handle exception
					//出现异常 ，给出提示
					System.out.println(e);
					JOptionPane.showMessageDialog(null, "保存失败 ","错误！", JOptionPane.ERROR_MESSAGE);
				}
					//关闭语句对象和链接对象
					finally{
						DB.closeStmt();
						DB.closeConn();
					}
				}
		}
			/*
			 * 根据JourNo
			 * ，返回人员信息各列值组成的字符数组
			 */
			public String[] search(String f1) {
				Database DB=new Database();
				this.field1=f1;
				//创建字符串数组 用于记录查询的数据
				String[] s =new String[6];
				sql="select * from Histrjn where JourNo="+field1;
				try{
					DB.openConn();//连接数据库
					//执行查询，查询结果付给rs，rs为结果集
					rs=DB.executeQuery(sql);
					//如果rs.next为true
					if (rs.next()) {
						//获取指定的值
						//说明：PersonID'DeptId salary均不是String类型
						//但在此简化处理，把取出值看作字符串，赋值给字符数组元素
						//方便统一待会返回值
						s[0]=rs.getString("JourNo");
						s[1]=rs.getString("FromAcc");
						s[2]=rs.getString("OldInfo");
						s[3]=rs.getString("NewInfo");
						s[4]=rs.getString("ChgTime");
						s[5]=rs.getString("RegDate");
						s[6]=rs.getString("PersonID");
					}else {
						s=null;
					}
				}catch(Exception e){
					
				}finally {
						DB.closeStmt();
						DB.closeConn();
					}
				return s;
				}
			/*
			 * 根据PersonID
			 * ，返回人员信息各列值组成的字符数组
			 */
			public String[] searchPI(String f7) {
				Database DB=new Database();
				this.field1=f7;
				//创建字符串数组 用于记录查询的数据
				String[] s =new String[6];
				sql="select * from Histrjn where PersonID="+field7;
				try{
					DB.openConn();//连接数据库
					//执行查询，查询结果付给rs，rs为结果集
					rs=DB.executeQuery(sql);
					//如果rs.next为true
					if (rs.next()) {
						//获取指定的值
						//说明：PersonID'DeptId salary均不是String类型
						//但在此简化处理，把取出值看作字符串，赋值给字符数组元素
						//方便统一待会返回值
						s[0]=rs.getString("JourNo");
						s[1]=rs.getString("FromAcc");
						s[2]=rs.getString("OldInfo");
						s[3]=rs.getString("NewInfo");
						s[4]=rs.getString("ChgTime");
						s[5]=rs.getString("RegDate");
						s[6]=rs.getString("PersonID");
					}else {
						s=null;
					}
				}catch(Exception e){
					
				}finally {
						DB.closeStmt();
						DB.closeConn();
					}
				return s;
				}
			}

人事管理系统——Dept表增删改查操作类

Mon, 07 Aug 2017 13:36:21 +0800

package com.jnzyjsxy.common;

import java.sql.ResultSet;

import javax.swing.JOptionPane;

public class DeptBean {
	//定义字符串用于存储sql字符串
	String sql;
	//结果集类
	ResultSet rs=null;
	//声明字符串变量 存储从操作界面传过来的人员信息
	String field1;
	String field2;
	String field3;
	//添加信息
	public void add(String f1,String f2,String f3) {
		//创建数据库对象 执行数据库里面的方法 链接数据库 执行sql语句
		Database DB=new Database();
		//将从添加界面传过来的值 付给成员变量
		this.field1=f1;
		this.field2=f2;
		this.field3=f3;
		if (field2==null || field2.equals("")) {
			JOptionPane.showMessageDialog(null, "请输入人员所在一级部门", "错误", JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field3==null||field3.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入人员所在二级部门","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		//构建插入字符串
				//构建sql字符串时，注意字符型，两侧用单引号做定界符，int,float不用定界符
				//传递过来的数据是字符型， 
				//为了插入int数据，进行类型转换-Integer.parseInt(field1) 
				//在此PersonID，DeptID均为int类型，Sqlary为float类型，与书上不同 
				else {
					sql="insert into Dept(DeptID,B_Dept,S_Dept) values("+Integer.parseInt(field1)+ ",'"+field2+"','"+field3+"')";
					System.out.println(sql);	
					//打开数据库连接
					try {
						DB.openConn();
						//执行sql语句
						DB.executeUpdate(sql);
						//提示信息
						JOptionPane.showMessageDialog(null, "你成功添加一条新的纪录");
					} catch (Exception e) {
						// TODO: handle exception
						//出现异常 ，给出提示
						System.out.println(e);
						JOptionPane.showMessageDialog(null, "保存失败 ","错误！", JOptionPane.ERROR_MESSAGE);
					}
						//关闭语句对象和链接对象
						finally{
							DB.closeStmt();
							DB.closeConn();
					}
			}
	}
	/*
	 * 修改设备信息
	 */
	public void modify(String f1,String f2,String f3){
		Database DB=new Database();
		this.field1=f1;
		this.field2=f2;
		this.field3=f3;
		if (field2==null || field2.equals("")) {
			JOptionPane.showMessageDialog(null, "请输入人员所在一级部门", "错误", JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field3==null||field3.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入人员所在二级部门","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		//构建插入字符串
		//构建sql字符串时，注意字符型，两侧用单引号做定界符，int,float不用定界符
		//传递过来的数据是字符型， 
		//为了插入int数据，进行类型转换-Integer.parseInt(field1) 
		//在此PersonID，DeptID均为int类型，Sqlary为float类型，与书上不同 
		else {
			sql="insert into Dept(DeptID,B_Dept,S_Dept) values("+Integer.parseInt(field1)+ ",'"+field2+"','"+field3+"')";
			System.out.println(sql);	
			//打开数据库连接
			try {
				DB.openConn();
				//执行sql语句
				DB.executeUpdate(sql);
				//提示信息
				JOptionPane.showMessageDialog(null, "你成功修改一条新的纪录");
			} catch (Exception e) {
				// TODO: handle exception
				//出现异常 ，给出提示
				System.out.println(e);
				JOptionPane.showMessageDialog(null, "保存失败 ","错误！", JOptionPane.ERROR_MESSAGE);
			}
				//关闭语句对象和链接对象
				finally{
					DB.closeStmt();
					DB.closeConn();
			}
		}
	}
	/*
	 * 删除信息 根据传过来的PersonId 删除信息
	 */
	public void delete(String f1) {
		//创建数据库对象
		Database DB=new Database();
		this.field1=f1;//获取传递过来的参数
		//构建删除人员的字符串
		sql="delete from Dept where DeptID="+Integer.parseInt(field1);
		try {
			DB.openConn();
			DB.executeUpdate(sql);
			System.out.println(sql);
			JOptionPane.showMessageDialog(null, "成功删除一条新的纪录");	
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e);
			JOptionPane.showMessageDialog(null, "删除失败", "错误", JOptionPane.ERROR_MESSAGE);
			
	}
		finally{
			DB.closeStmt();
			DB.closeConn();
		}
	}
	/*
	 * 从Dept表查询所有人员信息，DeptID列显示部门名称 
	 */
	public String[][] searchAll() {
		Database DB=new Database();
		//定义二维数组
		String[][] sn=null;
		int row=0;//行数
		int i=0;//循环变量
		//查询sql字符串
		sql="select * from Dept order by DeptID";
		try {
			DB.openConn();
			rs=DB.executeQuery(sql);
				if (rs.last()) {
					row=rs.getRow();//获取结果集rs中记录数，即行数
				}
				//如果row==0说明rs没有记录 既没有查到符号条件的记录
				if (row==0) {
					//初始化二维数组1行6列 每个元素为空白字符
					sn=new String[1][2];
					sn[0][0]="";
					sn[0][1]="";
					sn[0][2]="";
				}
				//否则rs不等于0
				else {
					//根据行数row 初始化二维数组sn
					sn=new String[row][2];
					//让rs指到第一条数据
					rs.first();
					//将指针移动到上一行 由于上一条语句记录指针到第一条数据
					//执行完这条语句后 记录指针移动的rs的头部分
					//执行该条语句的作用是保障所有的记录都能满足rs.next()条件
					rs.previous();
					while (rs.next()) {
						sn[i][0]=rs.getString("DeptID");
						sn[i][1]=rs.getString("B_Dept");
						sn[i][2]=rs.getString("S_Dept");
						i++;			
					} 
				}
		}catch (Exception e) {
			// TODO: handle exception
		}finally {
			DB.closeStmt();
			DB.closeConn();
		}
		return sn;	
	}
	/*
	 * 获得新的Dept值
	 */
	public int getId() {
		Database DB=new Database();
		int ID=1;
		//查询sql，从Person表获取PersonID列的最大值
		sql="select max(DeptID) from Dept";
		try {
			DB.openConn();
			rs=DB.executeQuery(sql);
			if (rs.next()) {
				ID=rs.getInt(1)+1;
			}else {
				ID=1;
			}
		} catch (Exception e) {
			// TODO: handle exception
			
		}
		finally {
			DB.closeStmt();
			DB.closeConn();
		}
		return ID;
	}
	/*
	 * 根据DeptID查询人员信息，返回人员信息各列值组成的字符数组
	 */
	public String[] search(String f1) {
		Database DB=new Database();
		this.field1=f1;
		//创建字符串数组 用于记录查询的数据
		String[] s =new String[10];
		sql="select * from Dept where DeptID="+field1;
		try{
			DB.openConn();//连接数据库
			//执行查询，查询结果付给rs，rs为结果集
			rs=DB.executeQuery(sql);
			//如果rs.next为true
			if (rs.next()) {
				//获取指定的值
				//说明：PersonID'DeptId salary均不是String类型
				//但在此简化处理，把取出值看作字符串，赋值给字符数组元素
				//方便统一待会返回值
				s[0]=rs.getString("DeptID");
				s[1]=rs.getString("B_Dept");
				s[2]=rs.getString("S_Dept");
			}else {
				s=null;
				}
			}catch(Exception e){
				
			}finally {
					DB.closeStmt();
					DB.closeConn();
				}
			return s;
	}
	
	/*
	 * 根据传递过来的ID 返回一级部门—耳机部门
	 */
	public String getDepstr(String string) {
		// TODO Auto-generated method stub
		Database DB=new Database();
		this.field1=string;
		//创建字符串数组 用于记录查询的数据
		String s = null;
		sql="select * from Dept where DeptID="+field1;
		System.out.println(sql);
		try{
			DB.openConn();//连接数据库
			//执行查询，查询结果付给rs，rs为结果集
			rs=DB.executeQuery(sql);
			//如果rs.next为true
			if (rs.next()) {
				//获取指定的值
				//说明：PersonID'DeptId salary均不是String类型
				//但在此简化处理，把取出值看作字符串，赋值给字符数组元素
				//方便统一待会返回值
				s=rs.getString("B_Dept")+"-"+rs.getString("S_Dept"); 	
			}else {
				s=null;
				}
			}catch(Exception e){
				
			}finally {
					DB.closeStmt();
					DB.closeConn();
				}
			return s;
	}
	
}

”无法解析类型这是简介引用的类文件要求从必需的 .class 文件间接引用了“——解决方法

Sun, 06 Aug 2017 19:30:39 +0800

百度翻译：

在线程的“主”java.lang.error例外：解决编制问题：类型javax.swing.jcomponent不能解决。这是间接引用的类文件的要求。

该方法在类型数据库executeupdate()不适用于参数（字符串）方法showmessagedialog（组件对象）在型JOptionPane不适用于参数（null，String，int）

COM。jnzyjsxy。常见。personbean。<初始化>（personbean。java：53） COM。jnzyjsxy。测试。文字。主要（文本。java：13）

这个编译错误有几个原因：

1、jdk版本问题

要是报错是某些java包里的东西那就可以肯定是jdk版本的问题，

比如无法解析类型java.lang.Object，无法解析类型java.lang.CharSequence.

解决方法：换jdk版本或者重装jdk

2、maven依赖的jar包有问题

当maven项目引用jar包的时候，有些jar包会失效，导致这个问题。

解决方法：把maven本地库jar包删除重新下载，或者删除后换个仓库下载。

人事管理系统——Person表增删改查操作类

Sun, 06 Aug 2017 19:27:53 +0800

package com.jnzyjsxy.common;

import java.sql.ResultSet;

import javax.sound.midi.VoiceStatus;
import javax.swing.JOptionPane;

import org.omg.CORBA.PUBLIC_MEMBER;
/*
 * 有关人员信息数据库操作的类
 */
public class PersonBean {
	//定义字符串用于存储sql字符串
	String sql;
	//结果集类
	ResultSet rs=null;
	//声明字符串变量 存储从操作界面传过来的人员信息
	String field1;
	String field2;
	String field3;
	String field4;
	String field5;
	String field6;
	String field7;
	String field8;
	String field9;
	String field10;
	
	String colname;//列名
	String colvalue1;//列值1
	String colvalue2;//列值2
	
	/*
	 * 添加信息
	 */
	public void add(String f1,String f2,String f3,String f4,String f5,
			String f6,String f7,String f8,String f9,String f10) {
		//创建数据库对象 执行数据库里面的方法 链接数据库 执行sql语句
		Database DB=new Database();
		//将从添加界面传过来的值 付给成员变量
		this.field1=f1;
		this.field2=f2;
		this.field3=f3;
		this.field4=f4;
		this.field5=f5;
		this.field6=f6;
		this.field7=f7;
		this.field8=f8;
		this.field9=f9;
		this.field10=f10;
		//判断穿过来的值是否为空 如果为空就显示提示语句
		if (field2==null || field2.equals("")) {
			JOptionPane.showMessageDialog(null, "请输入人员姓名", "错误", JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field3==null||field3.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入性别","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field4==null||field4.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入出生年月","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field5==null||field5.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入民族","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field6==null||field6.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入地址","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field7==null||field7.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入部门","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field8==null||field8.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入薪酬","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		//构建插入字符串
		//构建sql字符串时，注意字符型，两侧用单引号做定界符，int,float不用定界符
		//传递过来的数据是字符型， 
		//为了插入int数据，进行类型转换-Integer.parseInt(field1) 
		//在此PersonID，DeptID均为int类型，Sqlary为float类型，与书上不同 
		else {
			sql="insert into Person(PersonID,Name,Sex,Birth,Nat,Address,DeptID,Salary,Assess,Other) values("+Integer.parseInt(field1)+ ",'"+field2+"','"+field3+"','"+field4+"','"+field5+"','"+field6+"',"+Integer.parseInt(field7)+","+Float.parseFloat(field8)+",'"+field9+"','"+field10+"')";
			System.out.println(sql);	
			//打开数据库连接
			try {
				DB.openConn();
				//执行sql语句
				DB.executeUpdate(sql);
				//提示信息
				JOptionPane.showMessageDialog(null, "你成功添加一条新的纪录");
			} catch (Exception e) {
				// TODO: handle exception
				//出现异常 ，给出提示
				System.out.println(e);
				JOptionPane.showMessageDialog(null, "保存失败 ","错误！", JOptionPane.ERROR_MESSAGE);
			}
				//关闭语句对象和链接对象
				finally{
					DB.closeStmt();
					DB.closeConn();
				}
			}
		}
		/*
		 * 修改设备信息
		 */
	public void modify(String f1,String f2,String f3,String f4,String f5,
			String f6,String f7,String f8,String f9,String f10) {
		Database DB=new Database();
		this.field1=f1;
		this.field2=f2;
		this.field3=f3;
		this.field4=f4;
		this.field5=f5;
		this.field6=f6;
		this.field7=f7;
		this.field8=f8;
		this.field9=f9;
		this.field10=f10;
		if (field2==null || field2.equals("")) {
			JOptionPane.showMessageDialog(null, "请输入人员姓名", "错误", JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field3==null||field3.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入性别","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field4==null||field4.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入出生年月","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field5==null||field5.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入民族","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field6==null||field6.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入地址","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field7==null||field7.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入部门","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		else if (field8==null||field8.equals("")) {
			JOptionPane.showMessageDialog(null,"请输入薪酬","错误",
					JOptionPane.ERROR_MESSAGE);
			return;
		}
		//构建插入字符串
		//构建sql字符串时，注意字符型，两侧用单引号做定界符，int,float不用定界符
		//传递过来的数据是字符型， 
		//为了插入int数据，进行类型转换-Integer.parseInt(field1) 
		//在此PersonID，DeptID均为int类型，Sqlary为float类型，与书上不同 
		else {
			sql="updata into Person(PersonID,Name,Sex,Birth,Nat,Address,DeptID,Salary,Assess,Other) values("+Integer.parseInt(field1)+ ",'"+field2+"','"+field3+"','"+field4+"','"+field5+"','"+field6+"',"+Integer.parseInt(field7)+","+Float.parseFloat(field8)+",'"+field9+"','"+field10+"')";
			System.out.println(sql);	
			//打开数据库连接
			try {
				DB.openConn();
				//执行sql语句
				DB.executeUpdate(sql);
				//提示信息
				JOptionPane.showMessageDialog(null, "你成功修改一条新的纪录！");
			} catch (Exception e) {
				// TODO: handle exception
				//出现异常 ，给出提示
				System.out.println(e);
				JOptionPane.showMessageDialog(null, "保存失败 ","错误！", JOptionPane.ERROR_MESSAGE);
			}
			finally{
				DB.closeStmt();
				DB.closeConn();
			}
	}

}
	/*
	 * 删除信息 根据传过来的PersonId 删除信息
	 */
	public void delete(String f1) {
		//创建数据库对象
		Database DB=new Database();
		this.field1=f1;//获取传递过来的参数
		//构建删除人员的字符串
		sql="delete from Person where PersonID="+Integer.parseInt(field1);
		try {
			DB.openConn();
			DB.executeUpdate(sql);
			System.out.println(sql);
			JOptionPane.showMessageDialog(null, "成功删除一条新的纪录");	
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e);
			JOptionPane.showMessageDialog(null, "删除失败", "错误", JOptionPane.ERROR_MESSAGE);
			
	}
		finally{
			DB.closeStmt();
			DB.closeConn();
		}
}
	/*
	 * 根据PersonID查询人员信息，返回人员信息各列值组成的字符数组
	 */
	public String[] search(String f1) {
		Database DB=new Database();
		this.field1=f1;
		//创建字符串数组 用于记录查询的数据
		String[] s =new String[10];
		sql="select * from Person where PersonID="+field1;
		try{
			DB.openConn();//连接数据库
			//执行查询，查询结果付给rs，rs为结果集
			rs=DB.executeQuery(sql);
			//如果rs.next为true
			if (rs.next()) {
				//获取指定的值
				//说明：PersonID'DeptId salary均不是String类型
				//但在此简化处理，把取出值看作字符串，赋值给字符数组元素
				//方便统一待会返回值
				s[0]=rs.getString("PersonID");
				s[1]=rs.getString("Name");
				s[2]=rs.getString("Sex");
				s[3]=rs.getString("Birth");
				s[4]=rs.getString("Nat");
				s[5]=rs.getString("Address");
				s[6]=rs.getString("DeptID");
				s[7]=rs.getString("Salary");
				s[8]=rs.getString("Assess");
				s[9]=rs.getString("Other");
			}else {
				s=null;
			}
		}catch(Exception e){
			
		}finally {
				DB.closeStmt();
				DB.closeConn();
			}
		return s;
		}
		/*
		 * 人员信息综合查询
		 * 从PersonID和Dept表查询所有Where DeptID=Person.DeptID部门编号相等的记录
		 */
	public String[][] searchAllForNode() {
		//初始化数据库
		Database DB=new Database();
		//创建二维数组 存储查找到的符号条件记录的咯列值
		//由于符合条件的记录可能有多行，所以需要二维数组
		String[][] sn =null;
		int row=0;//存储行数
		int i=0;//循环变量
		//构建联合查询语句 查询条件where DeptID=Person.DeptID
		//从Person，Dept表查询Where Dept.DeptID=Person.DeptID 条件的指定字段
		sql="select PersonID,Name,Sex,Dept.DeptID as DeptID,B_Dept,S_Dept, Salary,Assess from Dept,Person where Dept.DeptID=Person.DeptID order by PersonID"; 
		try {
			DB.openConn();
			// TODO: handle exception
			//执行查询
			rs=DB.executeQuery(sql);
			//rs.last()--将记录指针移动到最后记录上，该方法类型为boolean
			//如果指针位于有效位,则返回true;如果结果集中不存在任何行,则返回false
			//即如果rs中有记录
			if (rs.last()) {
				row=rs.getRow();//获取结果集rs中记录数，即行数
			}
			//如果row==0说明rs没有记录 既没有查到符号条件的记录
			if (row==0) {
				//初始化二维数组1行6列 每个元素为空白字符
				sn=new String[1][6];
				sn[0][0]="";
				sn[0][1]="";
				sn[0][2]="";
				sn[0][3]="";
				sn[0][4]="";
				sn[0][5]="";
			}
			//否则rs不等于0
			else {
				//根据行数row 初始化二维数组sn
				sn=new String[row][6];
				//让rs指到第一条数据
				rs.first();
				//将指针移动到上一行 由于上一条语句记录指针到第一条数据
				//执行完这条语句后 记录指针移动的rs的头部分
				//执行该条语句的作用是保障所有的记录都能满足rs.next()条件
				rs.previous();
				//结果集下移一条数据 返回true 执行循环
				//如果没有执行re.previons()语句 在执行rs.next（），第一天记录就略过了。
				while (rs.next()) {
					sn[i][0]=rs.getString("PersonID");
					sn[i][1]=rs.getString("Name");
					sn[i][2]=rs.getString("Sex");
					//一级部门-二级部门，存储到sn[i][3]元素中
					sn[i][3]=rs.getString("B_Dept")+"-"+rs.getString("s_Dept");
					sn[i][4]=rs.getString("Salary");
					sn[i][5]=rs.getString("Assess");
					i++;
				}
				
			}
		}catch (Exception e) {

		}finally{
			DB.closeStmt();
			DB.closeConn();
		}
		return sn;
	}
	/*
	 * 修改Person表中 指定用户的部门信息，即修改Person表中的DeptID字段值
	 */
	public void updateDept(String f1,String f8) {
		Database DB=new Database();
		this.field1=f1;//PersonID
		this.field8=f8;//salary 薪资字段
		sql="update Person set Salary =" +Float.parseFloat(field8)+" where PersonID ="+Integer.parseInt(field1);
		try {
			DB.openConn();
			DB.executeUpdate(sql);
			JOptionPane.showMessageDialog(null, "劳资更改成功");
			
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e);
			JOptionPane.showMessageDialog(null, "更新失败", "失败",JOptionPane.ERROR_MESSAGE);
		}
	}
	/*
	 * 修改Person表中指定考核信息 即修改Person表中Assess字段值
	 */
	public void updateAssess(String f1,String f9) {
	Database DB=new Database();
	this.field1=f1;
	this.field9=f9;//考核字段
	sql="update Person set Assess = '"+field9 +"' where PersonID ="+Integer.parseInt(field1);
	try{
		DB.openConn();
		DB.executeUpdate(sql);
		JOptionPane.showMessageDialog(null, "人员考核成功");
	}catch(Exception e){
		System.out.println(e);
		JOptionPane.showMessageDialog(null, "更新失败", "失败",
				JOptionPane.ERROR_MESSAGE);
	}
	}

		

	/*
	 * 从Person表查询所有的人员信息 DeptID列显示部门名称
	 */
	public String[][] searchAll() {
		Database DB=new Database();
		//定义二维数组
		String[][] sn=null;
		int row=0;//行数
		int i=0;//循环变量
		//查询sql字符串
		sql="select * from Person order by PersonID";
		try {
			DB.openConn();
			rs=DB.executeQuery(sql);
				if (rs.last()) {
					row=rs.getRow();//获取结果集rs中记录数，即行数
				}
				//如果row==0说明rs没有记录 既没有查到符号条件的记录
				if (row==0) {
					//初始化二维数组1行6列 每个元素为空白字符
					sn=new String[1][6];
					sn[0][0]="";
					sn[0][1]="";
					sn[0][2]="";
					sn[0][3]="";
					sn[0][4]="";
					sn[0][5]="";
				}
				//否则rs不等于0
				else {
					//根据行数row 初始化二维数组sn
					sn=new String[row][6];
					//让rs指到第一条数据
					rs.first();
					//将指针移动到上一行 由于上一条语句记录指针到第一条数据
					//执行完这条语句后 记录指针移动的rs的头部分
					//执行该条语句的作用是保障所有的记录都能满足rs.next()条件
					rs.previous();
					while (rs.next()) {
						sn[i][0]=rs.getString("PersonID");
						sn[i][1]=rs.getString("Name");
						sn[i][2]=rs.getString("Birth");
						sn[i][3]=rs.getString("Nat");
						sn[i][4]=rs.getString("Address");
						//创建部门操作类DeptBean的对象
						DeptBean dBean=new DeptBean();
						sn[i][5]=dBean.getDepstr(rs.getString("DeptID"));
						i++;			
					} 
				}
		}catch (Exception e) {
			// TODO: handle exception
		}finally {
			DB.closeStmt();
			DB.closeConn();
		}
		return sn;	
	}
	/*
	 * 获得新的Person值
	 */
	public int getId() {
		Database DB=new Database();
		int ID=1;
		//查询sql，从Person表获取PersonID列的最大值
		sql="select max(PersonID) from Person";
		try {
			DB.openConn();
			rs=DB.executeQuery(sql);
			if (rs.next()) {
				ID=rs.getInt(1)+1;
			}else {
				ID=1;
			}
		} catch (Exception e) {
			// TODO: handle exception
			
		}
		finally {
			DB.closeStmt();
			DB.closeConn();
		}
		return ID;
	}
	/*
	 * 获得DeptID
	 */
	public String getDeptId(String f1) {
		Database DB=new Database();
		//根据传递过来的PersonID 即根据员工编号，查DeptID
		sql="select DeptID from Person where PersonID = "+f1;
		String deptid=null;
		try {
			DB.openConn();
			rs=DB.executeQuery(sql);
			if (rs.next()) {
				deptid=rs.getString("DeptID");
			}else {
				deptid="";
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			DB.closeStmt();
			DB.closeConn();
		}
		return deptid;
	} 
	/*
	 * 根据PersonID查找员工姓名
	 */
	public String getName(String f1) {
		Database DB=new Database();
		sql="select Name from Person where PersonID ="+f1;
		String name=null;
		try {
			DB.openConn();
			rs=DB.executeQuery(sql);
			if (rs.next()) {
				name =rs.getString("Name");
			}
			else {
				name="";
				
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			DB.closeStmt();
			DB.closeConn();
		}
		return name;
	}
	/*
	 * 从perSon表中查找所有PersonID Name字段 存储在s数组中 返回
	 */
	public String[] getAllId() {
		String[] s=null;
		int row=0;
		int i=0;
		Database DB=new Database();
		sql="select PersonID,Name from Person order by PersonID";
		try {
			DB.openConn();
			rs=DB.executeQuery(sql);
			if (rs.last()) {
				row=rs.getRow();
			}
			if (row==0) {
				s=null;
			}else {
				s=new String[row];
				rs.first();
				rs.previous();
				while (rs.next()) {
				s[i]=rs.getString(1)+"-"+rs.getShort(2);
				i++;
					
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e);
		}finally {
			DB.closeStmt();
			DB.closeConn();
		}
		return s;
	}
	}

JDBC数据库连接代码

Sat, 05 Aug 2017 17:02:45 +0800

package com.jnzyjsxy.common;
import java.sql.DriverManager;
import java.sql.ResultSet;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.Statement;
/*

数据库连接类

*/
public class Database {
//创建成员变量用于存储数据库连接的字符串或结果
//statement接口 用于执行静态sql语句 并返回它所生成的结果
private Statement stmt=null;
//结果集类
ResultSet rs=null;
//链接类
private Connection conn=null;
String sql;//存储sql语句
//mysql数据连接字符串
//“jdbc:mysql://localhost:3306/db_hrms”
//数据库名称db_hrms
//在数据库名称后，增加"?characterEncoding=GBK"，避免插入记录为乱码
String strurl=“jdbc:mysql://localhost:3306/db_hrms?characterEncoding=GBK”;//主机地址
String username=“root”;//用户名
String password=“123456”;//密码
//构造方法
public Database(){
}
/*

打开数据库连接

*/
public void openConn() {
try {
Class.forName(“com.mysql.jdbc.Driver”);
//DriverManager.getConnection启动器管理类的连接方法
//创建数据库连接对象三个参数 初始化conn
conn=(Connection) DriverManager.getConnection(strurl, username, password);
System.out.println(“数据库连接成功”);
} catch (Exception e) {
// TODO: handle exception

关于Class.forName(“com.mysql.jdbc.Driver”)

Thu, 03 Aug 2017 17:14:46 +0800

传统的使用jdbc来访问数据库的流程为：
Class.forName(“com.mysql.jdbc.Driver”);
String url = “jdbc:mysql://localhost:3306/test?user=root&password=123456″;
Connection con = DriverManager.getConnection(url);
Statement statement = con.createStatement();

最开始使用的时候，不明白为什么首先要加载一个驱动类，之后就可以取得了Connection了，很好奇DriverManager是怎么获得那个驱动类的信息，后来看了下com.mysql.jdbc.Driver这个类的源代码，豁然开朗了。原来在com.mysql.jdbc.Driver类中有这么一段静态初始化代码：
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException(“Can’t register driver!”);
}
}
也就是，在Class.forName加载完驱动类，开始执行静态初始化代码时，会自动新建一个Driver的对象，并调用DriverManager.registerDriver把自己注册到DriverManager中去。

ps1: Class.forName(String) 与ClassLoader.loadClass(String)的区别
Class.forName(String): 加载类，并且执行类初始化；可以通过Class.forName(String, boolean, ClassLoader)第二个参数来仅仅加载类不执行初始化；
ClassLoader.loadClass(String): 仅仅加载类，不执行类初始化；

ps2: 有时会看到这种用法：
Class.forName(“com.mysql.jdbc.Driver”).newInstance();
这是没有必要的，正如前述，静态初始化已经new了一个Driver的对象，注册到DriverManager中去，在此再建立一个Driver对象则是完全没有必要的，浪费空间。

ps3: 结合ps1，Class.forName(“com.mysql.jdbc.Driver”);相当于：
ClassLoader loader = Thread.currentThread().getContextClassLoader();
Class cls = loader.loadClass(“com.mysql.jdbc.Driver”);
cls.newInstance();
这种方法的问题同ps2, 浪费了一个Driver对象；

ps4: 在java 6中，引入了service provider的概念，即可以在配置文件中配置service（可能是一个interface或者abstract class）的provider（即service的实现类）。配置路径是：/META-INF/services/下面。详细信息见：https://docs.oracle.com/javase/6/docs/technotes/guides/jar/jar.html#Service%20Provider
而java.sql.DriverManager也添加了对此的支持，因此，在JDK6中，DriverManager的查找Driver的范围为：
1）system property “jdbc.drivers” 中配置的Driver值；
2）用户调用Class.forName()注册的Driver
3）service provider配置文件java.sql.Driver中配置的Driver值。
因此，在jdk6中，其实是可以不用调用Class.forName来加载mysql驱动的，因为mysql的驱动程序jar包中已经包含了java.sql.Driver配置文件，并在文件中添加了com.mysql.jdbc.Driver.但在JDK6之前版本，还是要调用这个方法。

转载自【Java编程精选】20个非常有用的Java程序片段

Wed, 02 Aug 2017 19:26:36 +0800

下面是20个非常有用的Java程序片段，希望能对你有用。内容比较早，有些函数可能过时了，但是总体思路是不错滴，供参考。

1、字符串有整型的相互转换

String a = String.valueOf(2);   //integer to numeric string
int i = Integer.parseInt(a); //numeric string to an int

2、向文件末尾添加内容

BufferedWriter out = null;     try {         out = new BufferedWriter(new FileWriter(”filename”, true));         out.write(”aString”);     } catch (IOException e) {         // error processing code     
} finally {         if (out != null) {             out.close();         }     }

3、得到当前方法的名字

转载自【Java编程精选】给Java新手的一些建议----Java知识点归纳(J2EE and Web 部分)

Mon, 31 Jul 2017 15:33:12 +0800

　　我本人在JAVA开发刚入行的时候，也是做了不少web相关的项目，之后渐渐地web使用比较少了，现在web开发的技术日新月异，不过一些基础知识还是类似，所以也把这部分内容稍作整理，以期望可以给大家一些经验。

这次主要涉及到的两大块内容: Web相关的， J2EE相关的技术

Web部分:

HTTP协议，HTTPS协议

　　对于HTTP请求，我主要会关注以下内容:

HTTP请求的模式: request/response

HTTP请求的方法：GET， POST， PUT，DELETE 等等

协议的具体格式: head + body

协议的各类返回码:1XX，2XX，3XX，4XX，5XX

Header中一些主要属性的含义和使用场景

HTTPS协议

Cookie的基本原理和使用场景

HTML， CSS

JavaScript：

　　因为自己对这个涉猎也不深入，所以也就不更多罗列了，以免误人子弟了。

Webservice

　　Webservice的实现方式多种多样，两者共同点是大家都是以HTTP协议为基础的，都可以跨域，跨语言进行访问。

Tomcat配置用户名和密码

Sat, 29 Jul 2017 12:47:51 +0800

1.在浏览器输入http://localhost:8080/，打开Tomcat自带的默认主页面，右侧有“administration”“documentation”等模块。选择“administration”下面的Tomcat Manager，提示需要输入用户名和密码。
2.在不知道用户名和密码的情况下，Tomcat Manager的用户名和密码可以到“Tomcat安装目录/conf/tomcat-users.xml”文件中进行查看。
3.默认情况下，Tomcat Manager的用户名和密码是注释掉的（在），即Tomcat Manager默认是禁用的。
4.要使用Tomcat Manager，就要对用户进行配置（或取消注释符即可使用已配置的用户）。对用户的配置需要放在<tomcat-users>和</tomcat-users>之间。重新启动Tomcat服务，再到Tomcat主页面点击“Tomcat Manager”，输入配置的用户名和密码，点击确定就可以进入到“Tomcat Web Application Manager”界面。
注意事项
- Tomcat Manager的用户名和密码配置在“Tomcat安装目录/conf/tomcat-users.xml”文件中查看和配置。

tomact自启动设置

Sat, 29 Jul 2017 11:56:14 +0800

该部分内容来源于网络，本人测试，功能正常，留下备忘。

适用于Tomcat4.1、5.5、6.0。

因为解压缩版的Tomcat，在windows服务上没有启动项，所以需要手动添加，然后可以设置开机启动tomcat。

一、安装服务

在命令行中进入/Tomcat路径/bin/，执行“service.bat install”：（开始-运行,输入cmd,cdTomcat路径/bin,service.bat install）。到此为止windows服务上就增加了一个tomcat服务

说明：

1、服务名和显示名称：service.bat中设置了默认的服务名称，不同版本分别命名为Tomcat4、Tomcat5、Tomcat6，如果需要自定义服务名或服务的显示名称，可在service.bat中修改SERVICE_NAME或PR_DISPLAYNAME；

2、防火墙的影响：/bin/tomcat6.exe（或tomcat4.exe、tomcat5.exe）将被作为服务程序，如果有防火墙，需要设为允许作为服务。

二、卸载服务

在命令行中进入/Tomcat路径/bin/，执行“service.bat remove”：

三、命令行参数

Tomcat的服务名、Jvm内存初始值和最大值等可通过命令行参数设置，请参考官方文档：

http://tomcat.apache.org/tomcat-5.5-doc/windows-service-howto.html

http://tomcat.apache.org/tomcat-6.0-doc/windows-service-howto.html

四、开机启动Tomcat设置

开始-控制面板-管理工具-服务

找到apche tomcat?右键属性，把手动改为自动

JavaEE (my eclipse10 以及 tomcat6配置教程)

Sat, 29 Jul 2017 10:56:56 +0800

所需工具:

(建议使用迅雷下载)

配置好的Java环境：点击浏览

My Eclipse破解版：点击下载（下载完成后按照压缩包里面的教程下载和安装My eclipse 自测成功！）

tomcat6.0:点击下载

tomcat在My Eclipse下的环境配置：

1.首先将下载好的压缩包解压解压到c盘的根目录下

1. 2.接下来开始配置环境变量，
  3.然后新建三个系统变量：
  TOMCAT_HOME=C:\apache-tomcat-6.0.20
  CATALINA_HOME=C:\apache-tomcat-6.0.20
  CATALINA_BASE=C:\apache-tomcat-6.0.20
2. 如图（变量值为39改成20）
4. 1. 4.在CLASSPALL中的最后添加;%TOMCAT_HOME%\lib\servlet-api.jar;
    5.在PAth中最前添加;%CATALINA_HOME%\bin;
    注意：前后顺序不影响
  2. 1. 至此，配置工作完成！打开bin文件夹，双击startup.bat
      它会自动打开如下控制台界面。
      不要关闭控制台界面，打开浏览器，输入http://localhost:8080
      出现Tomcat的网页，证明安装并配置成功！
      最后关闭控制台，关闭控制台即关闭Tomcat服务
    2. 接下来配置在my eclipse中配置tomcat6
    3. 首先确保你已经成功的安装了myeclipse10和tomcat

Java简介和安装教程

Sat, 29 Jul 2017 10:16:04 +0800

简介

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等

环境配置教程：

1、下载 JDK1.8:：点击下载

2、安装JDK

直接运行exe可执行程序，默认安装即可；
备注：路径可以选其他盘符，不建议路径包含中文名及特殊符号。

3、配置环境变量

win10下打开环境变量：此电脑（右击属性）-高级系统设置-环境变量

1新建变量名：JAVA_HOME，变量值：C:\Program Files\Java\jdk1.8.0_131

2 打开PATH，添加变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin
3新建变量名：CLASSPATH，变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar

备注：
1.表示当前路径，%JAVA_HOME%就是引用前面指定的JAVA_HOME；
2 JAVA_HOME指明JDK安装路径，此路径下包括lib，bin，jre等文件夹，tomcat，eclipse等的运行都需要依靠此变量。
3 PATH使得系统可以在任何路径下识别java命令。
4 CLASSPATH为java加载类(class or lib)路径，只有类在classpath中，java命令才能识别。

4、测试jdk

在CMD命令窗口下输入javac java javadoc命令，出现如下界面，则安装成功。

5,安装eclipse：点击下载

下载完成解压点击 eclipse.exe 文件即可运行

Java on 庞玉栋个人博客

Java两种方法实现简单爬虫

Java实现冒泡排序

如何从命令提示符运行Java程序

Kotlin 扩展函数详解与应用

一、什么是扩展函数？

二、扩展函数的使用

（1）函数的扩展

● 在 Toast 中的高级用法

聊聊分布式事务，再说说解决方案

前言

数据库事务

分布式理论

CAP定理

我们JAVA开发学习的七大作为

五分钟学会 Kotlin 语法

为什么使用Kotlin

修改说明

Kotlin 基本语法

java mail实现Email的发送,完整代码

Java学习笔记--SSH框架整合(struts2、spring4、hibernate5)

【SSH网上商城项目实战30】项目总结（附源码下载地址）

0. 写在前面

1. 项目环境的搭建

2. 搭建后台管理系统

2.1 商品类别的管理

2.2 商品的管理

3. 搭建前台显示页面

4. 购物车相关功能

SSH框架整合demo

Struts、Spring、Hibernate整合

一、创建web工程，搭建Struts框架开发环境：

二、搭建Hibernate开发环境：

三、搭建Spring开发环境：

四、Spring与Hibernate整合：

五、Spring与Struts整合：

整合之前：

Java精选笔试题

1，volatile关键字是否能保证线程安全？（）

2，下面哪个流类属于面向字符的输入流( )

Java小技巧，从运行、控制到框架

Spring 知识点提炼

java多线程高级教程，这些你都懂了吗？

Java入门学习进阶知识点汇总

Java数据结构与算法

Java在各个操作系统中的安装方式

GitHub 上最火的 Java 框架

历数Java程序员面试失败的5大原因

＃1 说得太少

＃2 说得太多

＃3回答不出一些必知的基本技术问题

＃4既写不好简单的代码，又回答不出如何解决棘手的问题

＃5糟糕的礼仪和态度

Java数据结构与算法

Java打飞机小游戏（附完整源码)

敌飞机

分数奖励

蜜蜂

子弹类：是飞行物体

敌人的分数

飞行物(敌机，蜜蜂，子弹，英雄机)

英雄机

游戏启动主类

深入解析Java垃圾回收机制

分享优秀Java程序员应有的编程风格

Java集合面试问题和答案

Java字符串的10大热点问题盘点

1、如何比较字符串，应该用”==”还是equals()？

2、对那些安全敏感的信息，为什么用char[]存储要优于String？

3、能否用字符串来声明switch语句？

4、如何将字符串转换成数字int类型？

5、如何用空格字符来分割字符串？

6、substring()方法究竟是什么？

7、String、StringBuilder和StringBuffer哪个更优？

8、如何重复输出字符串？

9、如何将字符串转换成日期类型？

10、如何统计指定字符在字符串中出现的频率

JVM 语言的兴衰史

死磕 Java 并发 ：Java 内存模型之 happens-before

Java知识点归纳-J2EE 、 Web 部分

死磕 Java 并发：Java 内存模型之 happens-before

Java My SQL 数据库用法操作代码

构建联合查询语句用于查询三联表中的数据

在有main函数的前提下 eclipse找不到主类解决办法

Node11Panel类添加人员信息操作

HistrinBean.java 类，用亍实现对历史流水相关信息进行数据库操作的功能，包括增加流水信息、提供多种方式的查询等

”无法解析类型这是简介引用的类文件要求从必需的 .class 文件间接引用了“——解决方法