JAVA编程学习经验实践积累总结分享

@Wanzhong Liao

1. 大量群发邮件：购买Edm服务，大的互联网企业是和邮箱服务商签订协议（百度，腾讯，京东，阿里，csdn）

站内信

内网发短信：短信猫

2. Servlet Filter 生命周期*Servlet：看配置文件中web.xml配置其启动的优先级别，即当load-on-startup的值为大于等于0时，控制器

随服务器的启动初始化，随服务器的终止销毁，否则用户请求Servlet（控制器）时初始化Servlet,

随服务器的终止而销毁。*Filter：服务器启动即初始化Filter（过滤器），终止时销毁。

3. javaSE

多线程 〉实现方式：1. 继承扩展Thread类〉代码：实体：自定义线程，继承Thread类，其实Thread也是实现了Runnable接口class TestThread extends Thread

/覆写run方法@Overridepublic void run()/打印3个线程的名字for(int i=0;i<3;i++)

/打印线程系统默认的名字System.out.println(Thread.getCurrentThread().getName());

/测试，主方法public class Test

public static void main(String[] args)/新建自定义线程

TestThread testThread=new TestThread();/线程就绪，调用run方法new Thread(testThread).start();new Thread(testTread).start();

2. 实现Runnable接口：同上，只是实现类接口，而不是扩展类。*线城池 ：生产者与消费者的数据共享与仓储即是个线城池。*生产值与消费者模式：见下文

4. 生命周期4.1 代码块：用大括号（表示开始和结束）扩起来的代码即是代码块，再用static关键字描述就是静态代码块，

类加载时即初始化。代码块的变量生命周期即在代码块中。4.2 不同变量生命周期：*循环变量：在循环体中。*子程序：在子程序中，即方法体中。*类变量：全局变量，即静态变量，属于类所有。*private：在当前类中有效。*protected: 在当前类和子类中都有效。*public：作用域最大，所有类型都可以访问。

5. io流：*字节流： InputStream（输入字节流） OutputStream（输出字节流）*字符流：reader writer*文件流：FileInputStream FileOutputStream：文件输入输出流，其中保存的是文件的内容流。

6. 集合 *List >ArrayList: 实现方式为数组结构，访问效率高，使用的比较多。 >LinkedList: 双向链表结构，插入和删除多的时候用该链表。*Set>HashSet：集合里的值具有唯一性，不能有重复值，无序，在表映射文件中必要排序的时候可以配置为

order-by=列值

Map>HashMap：访问效率高，用的比较多，键值可以为null，对象值也可以为null，线程不安全。HashTable：相比HashMap是同步的，当然效率要低，线程安全，键值对象值不可以为空，用的比较少。

7. SQL *左连接：以主表为准，从表没有对应的数据设置值为null. *内连接： 主从表都有的数据，取出重复的笛卡尔积。*右外连接： 以从表为准， 主表没有对应的数据设置值为null.*子查询： 从子查询语句过滤出的集合中再次过滤出你想要的数据集合。*多表查询：一般过滤条件要加上从表的外键等于主表的主键，再加上必需的过滤条件，再查询你想要的数据。

8. 简历简明扼要 穿着落落大方

10. javaEE 框架*ssh(Struts2+Spring+Hibernate)*ejb:Spring的前身，也是对象工厂*jpa：是对象持久化规范，Hibernate是产品*SpringMVC：框架，和Struts的作用一样

11. 常用设计模式和算法 ：*简单工厂模式：工厂和产品组成。*工厂模式：增加了抽象产品和抽象工厂，增加了可扩展性。*抽象工厂模式：抽象产品是否可以有多个实例化的对象，这个是和工厂模式的区别。*策略模式：由环境角色类，策略接口类，具体策略类构成。具体策略类实现策略接口类，自定义自己的方

法（算法）环境角色类依赖具体策略类，并实例化具体策略类，就是在构造函数中往依赖对象中塞值，

实例化具体策略类，并提供外部调用的接口，就是具体策略类调用自己定义扩展的方法（算法）。*适配器模式：目标接口 适配器 被适配者。

12. 常用Linux命令：记住常用的

12. 根据公司业务简述简历上写的框架的功能，使用场景

把公司业务讲清楚，把项目架构讲清楚，框架是如何用的，工作的职责，自己擅长的技术。

13. 项目经验问得很细

项目流程：

项目数据：每天处理多大的数据量，处理一次Job要多少时间

项目团队：多少人，怎么分工，自己的位置

项目问题：

14. 层叠样式表的特殊属性：*left: -1px：左位移；*bottom: -1px： 相邻元素向上位移；*z-index: 0：层叠权限级别，就近原则，权限越大的叠在上面；

2015/8/18

1. java传值

2015/8/19

1. 两张表的插入，要添加事务2. 表中的时间戳，数据库自动添加，建表时要设置时间的字段为默认当前时间戳，例如：date timpstamp default CURRENT_STAMP。3. 订单的下单时间：String.format("%tF %tT",new Date());？不理解格式4. request.getParamterMap()：表单提交的参数；request.getParameter()：get请求提交的参数；5. 要考虑空指针异常，增强代码健壮性。6. 下拉列表的回显，jstl,el*第一种方式：<select id="" name="">

<c:forEach items="" var="">
<option value="" <c:if test="">selected:selected</c:if></option>
</c:forEach>
</select>

第二种方式：麻烦点〈select name="">

<c:forEach items="" var="">
<c:choose>
<c:when test="">
<option value="" selcted="selected"></option>
</c:when>
<c:otherwise>
<option value=""></option>
</c:oterwise>
</c:choose>
</c:forEach>
</select>

6：易宝支付：

7：异步请求，*$.ajax()，七个属性：async:true/false,cache:false,url:"",data:{,},type:"POST",dataType:"json",

success:function(result);*$.load()*$.get()*$.post(url,data)8：下拉列表，$("#id").empty();/删除元素的子元素〈option〉元素本身并不删除

9；返回时浏览器倒退，不会访问服务器10：全站请求编码过滤器：*自定义的：代码：public class EncodingFilter implements Filterprivate String charset="utf-8";public void destroy()

public void doFilter(ServletRequest req,ServletResponse resp，
FilterChain chain)
HttpServletRequest request=(HttpServletRequest)req;if(request.getMethod().equalsIgnoreCase("GET"))if(!request instanceof GetRequest)/处理get请求编码
request=new GetRequest( requset,charset);
else/设置POST请求编码为默认编码utf-8request.setCharacterEncoding();
chain.doFilter(request,resp);
public void init(FilterConfig fConfig) throws Exception
String charsetfConfig.getInitParameter("charset");if(charset!=null & !charset.isEmpty())this.charset=charset;
n*Spring框架提供的CharacterEncodingFilter〉配置：<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>*</url-pattren>
</filter-mapping>

11.

MySQL数据类型：tinyint（小整形），UNIQUE KEY `loginname` (`loginname`)：字段值唯一，没有重复值

MySQL数据库引擎：

InnoDB: 提供事务，行级锁，适用于表更新，插入频繁。

MyISAM：查询效率高，没有事务。

12. 实体设计：

主键

一般属性

特殊属性（可获得的属性：时间，当前用户 。需计算维护的属性：count）

关联关系（双向关联，前向关联：多对一较多，看表中的字段，页面的数据关联的情况）

实体的类型尽量用包装类型，防止nll赋值出现异常，基本类型一般用在运算中，效率高。

13. 有用的工具：自定义通用工具，用在不用框架的web开发

CommonUtils:
public class CommonUtils
/返回32位通用唯一标识符，是去掉其中的4个_的
public static String uuid()
return UUID.randomUUID().toString().replace("_","");
/把map转换为clazz型的bean
public static <T> T toBean(Map map,Class<T> clazz)
try
/通过clazz穿件实例化bean
T bean=clazz.newInstance();
/字符串到日期的转换
ConvertUtils.register(new DateConverter(),java.util.Date.class);
/构成bean，把map中的数据封装到bean中
BeanUtils.populate(bean,map);
return bean;
catch(Exception e)
throw new RuntimeException();
public class DateConverter implements Converter
@Override
public Object convert(Class type,Object value)
/如果要转换的值为空指针，那么直接返回Null
if(value==null)
return null;
/如果要转换的值不为字符串，那么就不转换了，直接返回对象value
if(!(value instanceof String))
return value;
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
try
return sdf.parse(value);
catch(ParseException e)
throw new RuntimeException();

2015/8/20

1. HttpServlet:doGet(),doPost(),service();

2. 父类转子类：父类转子类是向下转型，需要强转，原则：父类型的引用指向的是哪个子类的实例，就能转向哪个子类的引用。

3. 通用工具类：使用

/用来作为其他Servlet的父类，Struts的Action很像
public class BaseServlet extends HttpServlet throws ServletException,IOException
/覆写service方法，调用用户想要调用的方法
@Override
public void service(HttpServletRequest request,HttpServletResponse response)
/设置相应编码
response.setContentType("text/html;charset=utf-8");
/获取method参数，它是用户想调用的方法
String methodName=request.getMethod("method");
/方法对象
Method method=null;
/通过方法名获取方法对象
try
method=this.getClass.getMethod(methodName,HttpServletRequest.class
HttpServletResponse.class);
catch(Exception e)
/编译时异常转化为运行时异常，不要一味地抛异常，会增加复杂度
throw new RuntimeException(e);
try
/调用用户的方法之后的返回值，这里是字符串：("f:goods/UserServlet")
String result=method.invoke(this,request,response); 
/根据返回结果，决定是否转发还是重定向，默认为转发
if(result!=null & !result.isEmpty())
/
int index=result.indexOf(":");
/如果没有返回值，就默认转发
if(index=-1)
request.getRequestDispather(result).forward(request,response);
else
/拆分字符串，分割出前缀
String start=result.356lo9095/(0,index);
/要转发或重定向的路径
String path=result.substring(index+1);
if("f".equals(start))
/前缀为f"，表示转发
request.getReqeustDispather(path).forward(request,response);
else if("r".equals(start))
/前缀为r"，表示重定向
respose.sendRedirect(this.getServletContext+path);
catch(Exception e)
throw new RuntimeException(e);

4. 自定义JdbcUtils

5. JQuery插件：

JQuery_validate

JQuery_complete

JQuery_treeview

fckeditor：富文本编辑器

6. 结构化数据（数据库） 半结构化数据(xml,html)

7. 验证码：防止恶意攻击，机器人注册，暴力破解。

Java：一处编译，到处运行。

×自定义；用AWT（Abstract Window Toolkits，依赖本地的类库，平台依赖性）实现，有点费劲

用例：VerifyCode

/验证码：实体类
public class VerifyCode()
/验证码矩形宽高
private int width=70;
private int hight=35;
/随机数，下面有用
private Random random=new Random();
/验证码中的字体类型
private String[] fontNames={};
/矩形框背景色，默认为白色
private Color bgColor=new Color(255,255,255);
private String codes="";
/验证码文本，此处为字符串
private String text;
/画3条线，随机长度（范围自定义），颜色为蓝色
public void drawLine(BufferedImage image)
/画线条数据
int num=3;
/得到2维制图工具
Graphics2D g2=image.getGraphics();
/循环画3条线
for(int i=0;i<num;i++)
/分别得到画线两个点的坐标
int x1=random.nextInt(width);
int y1=random.nextInt(height);
int x2=random.nextInt(width);
int y2=random.nextInt(height);
/设置画笔为1.5px框
g2.setStroke(new BasicStroke(1.5F));
/设置线条夜色为蓝色
g2.setColor(Color.blue);
/划线
g2.drawLine(x1,y2,x2,y2);
/创建缓冲区图片
public BufferedImage createImage()
/创建缓冲区图片
BufferedImage image=new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
/得到2维制图工具
Graphics2D g2=(Graphics2D)image.getGraphics();
/划线
g2.fillRect(0,0,width,height);
return image;
/获取图片接口，其中绘制4个字符串，设置字体，颜色。
public BufferedImage getImage()
/创建缓冲区图片
BufferedImage image=createImage();
/得到制图工具
Graphics2D g2=image.getGraphics();
/设置字符串建立者（效率高）
StringBuilder sb=new StringBuilder();
/画4个字符串
for(int i=0;i<4;i++)
/设置要绘制的字符
String str=getRandomChar();
/追加字符
sb.append(str);
/设置线条字体
g2.setFont(getRandomFont());
/设置线条颜色
g2.setColor(getRandomColor()); 
/基线点横坐标
int x=i*1.0F*width/4;
/基线点纵坐标
int y=height-5;
/画4个字符
g2.drawString(str,x,y);
/text的setter
this.text=sb.toString();
drawLine(image);
/供外部访问的接口，得到text
public String getText()
return text; 
/得到随机字体
public Font getRandomFont()
/
int index=random.nextInt(fontNames.length);
/字体名字
String fontName=fontNames[index];
/字体样式
int style=random.nextInt(4);
/字体大小
int size=random.nextInt(5)+24;
return new Font(fontName,style,size); 
/获得随机字符串
public char getRandomChar()
int index=random.nextInt();
return codes.charat(index);
/获得随机组合色
public Color randomColor()
int red=random.nextInt(150);
int green=random.nextInt(150);
int blue=random.nextInt(150);
/
return new Color(red,green,blue); 
/工具类
Swing:awt的升级版，用java实现，效率较awt低，但是封装之后效果更好

2015/8/22

1. request.getParameterMap()：获取表单参数

2. $("#").css("display",""); ：显示区块

2015/8/23

1. 邮箱的用户名：

2. 邮箱的格式校验：if(!([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\[a-zA-Z0-9_-]{2,3}){1,2})$/test(value)){}

3. 显示元素：ele.css("display", "");

4. js的非空校验，空串校验

5. web.xml配置：

contextConfigLocation: 配置ContextLoaderListener的Spring配置文件 
encoding：请求相应编码配置参数 
Spring配置：
configLocation: SessionFactory的配置参数，一般为classpath下的hiberbate.cfg.xml文件

2015/8/25

1. 路径问题：

服务端路径，推荐使用绝对路径（/控制器.例如：UserServlet?"/服务端会解析为服务器+项目名称）

客户端路径(js,css,html,jsp)，使用绝对路径，用相对路径会出现问题，例如文件出现移动之后。

"/客户端只会解析为服务器名，所以项目部署到服务器的根路径下会出现问题。

2. 统一编码问题：

开发环境编码（编译环境：utf-8） 服务器编码（iso8859-1，自己不能配置） 数据库编码（自定义为utf-8）

3.

/*

1. 得到所有的错误信息，循环遍历之。调用一个方法来确定是否显示错误信息！*/

$(".error").each(function()

showError($(this));/遍历每个元素，使用每个元素来调用showError方法｝);*JQuery中用到很多的回调函数，方法中传的对象是函数指针。4. 回调函数：其实就是函数指针，调用者调用回调函数之后再返回来调用者。5. 递归函数：函数本身自己调用自己，方法体中加上处理数据的代码，一般最后调用自己，例如树状列表，可以用递归

实现。6. 事件和委托：事件是封装多的委托的实例，委托和事件都是函数指针？？7. CORBA：(Common Object Reqeust Broker Architecture)，通用对象请求代理架构，用在电信，移动，数字电视系统

领域8. uri和url，继承关系，url是加上了服务器的请求路径，uri纯粹是工程名的请求路径9. 注意拼写错误10. JQuery选择器的作用：得到元素对象，然后才可以作为调用者或者是函数参数，js也是面向对象编程，没有编译器错误

信息提示，所以很容易出错。11. 邮件发送？？12. war包13. ant14. webLogic

2015/8/26

1. pom.xml文件：Project Object Model，项目对象模型2. maven生命周期：清理 编译 测试 报告（文档） 打包 部署3. log4j和slf4j-log4j：*slf4j和commons-logging只是一个日志门面，实际还是要依赖真正的日志库log4j，虽然slf4j和commons-loggin

都自带了日志库，但是毕竟log4j才是最强大的。*slf4j和log4j的组合方式：slf4j-api-1.5.11.jar>slf4j-log4j12-1.5.11.jar>log4j-1.2.15.jar>log4j.properties*log4j和commons-logging的组合方式〉commons-logging-1.1.jar>log4j-1.2.15.jar>log4j.properties

4. 适配器模式，目标接口 适配器 被适配者（被依赖）5. null，""," "，三者区别*String str=null；是指字符串变量为空引用，还没有分配地址。还没有被实例化。*String str=""；是指字符串变量为空串，有地址，已经被实例化。*String str=" "；是指字符串为空白格，有地址，已经被实例化。6. 字符串6.1 处理方法：*trim()：去除字符串的首尾空白格*append()：StringBulider或StringBuffer的追加方法，一个线程不安全，另一个线程安全，但效率低。*substring()：子串，

有两个重载的方法，

substring(beginIndex,endIndex)：返回截取并返回开始索引到结束索引减1的字符串。

substring(beginIndex)：返回截取开始索引到字符串的结尾的字符串。*replace()：字符串的替换*indexOf()：从左向右第一个出现该字符的索引位置*lastIndexOf()：从右向左第一次出现该字符串的索引位置6.2 比较方法：*==：比较的是字符串的地址。*equals()：比较的是字符串的内容。7. 读取外部配置的属性文件：properties*代码：参数为classpath（类路径）下的资源文件的路径地址

InputStream input=this.getClass().getClassLoader().getResourceAsStream("");/新建一个属性集合，Properties继承与HashTable，线程安全
Properties prop=new Properties();/有关数据流的读取一般都要有处理异常try/加载数据流prop.load(input);
catch(IOException e)throw new RuntimeException();
/读取资源文件中的键相对应的对象值

prop.get("key");8. 变量作用域：循环变量，子程序， 类变量，类私有变量，类保护变量，类公共变量，从小到大递增。9. 不要基于一种语言编程，而是要深入一种语言去编程。10. 在最初的编码阶段少犯错误，在调试阶段快速地找到错误。11. 循环就是用来操作数组的。12. 你用的语言将很大程度上影响到你的解决方案。13. 堆（heap）和栈（stack）的区别*1. 申请方式和回收方式：stack：申请和释放由编译器控制，由编译器自动管理，无须程序员手工操作。heap：申请和释放由程序员控制，并制定分配内存的大小。*2. 申请后系统的响应上：stack: 只要栈的剩余空间大于申请空间，系统将为程序提供内存，否则提示栈溢出。heap: 动态制定分配内存的大小。首先应该知道操作系统有一个记录内存地址的链表，当系统收到程序的

申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆节点，然后将该节点从空闲节点链表

中删除，并将该节点的空间分配给程序。对于大多数系统，会在这块内存空间的首地址处记录本次

分配的大小。这样，代码中的delete语句才能正确地释放本内存空间。另外，由于找到的堆节点大

小不一定正好等于申请的大小，系统会自动地将多余的那部分重新放入空闲链表中。*3. 申请大小的限制：stack：在WINDOWS上，栈是向低地址扩展的数据结构，栈的大小是2M。heap：堆是向高地址扩展的数据结构，是不连续的链表结构，一般在32操作系统下，堆内存可以达到

4G的空间。*4. 分配空间的效率上：stack：效率高。heap：一般比较慢，而且还会产生内存碎片。*5. 存储内容：stack: 一般是函数指针，和函数的参数列表，以及局部变量。注意：静态变量是不入栈的。heap：一般对的头部用一个字节存放堆的大小，由程序员决定分配存储的内容。*6. 效率〉stack：运行效率高。heap：效率比stack 低。

14. 你用递归能做的，同样也可以用栈和循环来做。

2015/8/27

1. 程序编码是为了在机器能运行的基础上，使人能够看懂，即增加可读性，可维护性，可扩展性。2. 除非万不得已，否则千万不要使用goto.3. 多个return可以增加子程序的可读性和可维护性，同时可以避免产生很深的嵌套逻辑，但在使用它的时候要多加小心。4. 递归能够很优雅地解决一部分小问题，但在使用的时候要多加小心。简单的问题可以用递归。复杂的问题可以用循环加

栈（即迭代）来解决。5. *不常见的代码控制结构有：子程序的多处返回(return) ，递归， goto。*常见的代码控制结构有：顺序结构，判断结构，循环结构。6. maven clean?

7.

hibernate 的二级缓存配置：*配置文件〈!-－开启二级缓存，缺省是真－->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-－二级缓存提供商－->
<property name="hibernate.cache.provider_class"></property>
<!--hibernate自己管理二级缓存－->
<class-cache usage="" class="" /

8. 硬编码和软编码：是否可以自定义配置信息，是否有更好的扩展性。9. 抽象类和接口的区别：*是否有成员变量。*接口知识方法的声明，没有实现，抽象类可以有方法地实现，也可以有供子类复写的抽象方法。*抽象类是有abstract关键字。*java中接口可以有多继承。而抽象类只能是单继承。*接口解耦，抽象类的耦合度更高，因为是继承。

10. java

目标：高内聚，低耦合。

口号：一处编译，到处运行。11. 编程

目标：可扩展性，可维护性，可读性，可行性。

实现方式：接口和继承事项可扩展性，良好的编码习惯（变量命名，函数命名，代码结构）可增加可读性，可维护性，

充分地需求分析，项目设计增加项目的可行性。12. 表的映射：主从表关系，一般从表里有参照主表的外键，这里有三种关系，一对多关系，多对多关系，一对一关系

其中一对多关系用的最多。13. MVC设计模式：模型－视图－控制器*模型是：DAO,Service,JavaBean，从而生成数据。*视图是：Jsp，asp等显示数据的页面，数据载体显示方式一般为表格或者是列表。*控制器是：Action（动作），是控制中心，准备数据，请求响应的分发器。14. Map/HashMap/HashTable List/vector/ArrayList/LinkedList Set/HashSet Stack*HashMap和HashTable的区别：与vector和List的区别一样，就是线程安全问题（是否同步），以及访问效率的问题。HashTable是线程安全的，访问效率比HashMap 低。键值对是否为null,HashMap可以为null。*ArrayList和LinkedList的区别：ArrayList使用数组实现，因此访问的效率要高。双向链表使用的是用链表的数据结构，因此插入和删除的效率要高。*HashSet：元素没有顺序，没有重复的元素值。但是，必要的时候特别是在XXX.hbm.xml文件中可以配置为有序的。*Stack：在Java中栈是用Vector实现的，继承于Vector。15. 重构的重要性：使代码结构清晰，可读性提高。

2015/8/28

1. Cookie（可以设置保存时间）：用户把浏览器信息存于用户客户端。例如：用户保存用户注册信息（用户名）于客户端

2. Session：是用户会话（也可以设置Session失效时间），用于把用户信息存于服务端。

3. JQuery日历插件：datepicker ? JQuery UI的知识，有时间要学的。

4. 功能界面的布局：使用技术是DIV+CSS，使用区块一个一个拼凑起来的，如果你标签元素里还有子元素，则用DIV，

否则用内嵌文本元素span.

5. HTML标签元素：*常用块级元素有：DIV P H1 H2（用得比较多） ol li table*常用行内元素有：能控制宽高的，就是内嵌区块元素（inline-block，不自定义长宽时有默认的长度和宽度）:

img input textarea select 〉不能控制宽高的（可以设置左右内边距，外边距）：a span

6. 图书商城的用户模块的用户登录功能，可以用到Cookie和Session技术，优先级为先看Sesison是否有值，否则用保存于

Cookie中的信息。

7. 使用框架的一般步骤：导包〉配置〉使用

8. 表单客户端校验：*有三个事件〉输入框获得焦点事件：$().focus();〉输入框失去焦点事件：$().blur();〉表单提交事件：$().submit();*输入框的校验有三个步骤：1.非空校验：输入值是否为空〉2.格式校验：如：输入值的长度限制〉3.异步请求校验（服务端校验，这是真正的表单数据校验）：和服务器端的数据进行对比校验

9. 可以从tomcat的server.xml配置文件中，配置服务端口号为80（和http请求服务端口号是一样的？？），这样URL就可以省略写服务端

口号，直接请求协议+服务器名称就可以访问目标网站。

10. 虚拟路径：Struts2中Action配置为：namespace属性；Struts1中配置为name属性。

11. 虚拟主机：可以配置映射为localhost IP为127.0.0.1。

12. 焦点图？？

13. 选项卡的实现。*实现思路：

使用输入框按钮和区块来实现，得到按钮元素数组，对每个按钮体检单击事件，设置所有的按钮的样式为

空，并隐藏区块，然后给当前按钮添加样式，显示当前索引的区块元素。

14. MVC中显示层表示数据的方式为：以表格为载体，或者是列表。

15. 编程的目标：简化，简化，再简化。=结构清晰，增加可读性。

16. 私服？？

17. 单点登录？？

18. response:

response.getWriter()：得到字符输出流。

response.getOutputStream(): 得到字节输出流。

19. 一般html元素没有子元素的时候可以不用命名，可以直接用标签元素名用于层叠样式表的渲染或者js文件夹特效。

20. 不择手段，非豪杰，不改初衷，真英雄。

21. 嘴要甜，手脚要勤快，功夫还要练，遇到什么难处都不要怕。

22. js脚本编程中的事件响应对象是浏览器，就像图形界面编程中的事件响应对象是操作系统一样，web编程中get，post

的响应对象是服务器，js脚本编程中的常用事件为：focus（聚焦）,blur（失焦），submit（表单提交），click（单击事件）

mourseout（鼠标移入事件）,mourseover（鼠标移出事件）。

23. 无论遇到什么，都要坚强，朋友很重要，说白了就是好朋友很重要。

24. 学习JQurey，选择器很重要，有类别选择器，属性选择器，元素选择器 编号选择器，操作对象是对DOM元素，操作方

是对层叠样式表渲染页面的add和remove，以及对元素属性的设置值和移出值，从而添加对事件响应之后的特效，

例如：鼠标移入移出区块的背景色的调节，或者是对元素按钮背景图片的更换，输入框聚焦和失去焦点事件响应之后

的标签元素的显示和取消，数据校验，表单提交事件的前端校验等等。

25. 前端是面向浏览器编程，目的是如何显示数据， 服务端是面向服务器编程，目的是如何处理数据，数据库端是面向数据

库编程，目的是如何持久化数据。

2015/8/29

1. 单例模式*懒汉式：（多线程高并发访问时要考虑同步问题）〉代码，以用户实体为例(User)

publiuc class User

/*1. 用户实体，静态全局依赖，类加载时即初始化为空指针，没有内存地址，但还

是可以引用*/private static User instance=null;

/2. 私有的构造函数，外部不能有以new关键字在堆内存中新创建的对象private User(){}

/懒汉式，懒加载实例化的对象public static synchronized User getInstace()

/如果实例化对象为空指针if(instancre==null)/实例化当前对象

instance=new User();return instance;

else/否则返回当前实例化的对象return instance;

*饿汉式：代码，以用户实体为例(User)：public class User

/类加载即初始化user对象，饿汉式，饥饿加载private static User instance=new User();

/供外部访问接口，得到供外部访问的实例化对象public static User getInstance()return instance;

/私有构造函数，模拟数据库private User()

注：单例模式，只应许有一个类的实例，所以构造函数是私有的。*懒汉是不是在类加载时初始化类的实例化对象，不能保证对象的唯一性，所以在多线程的情况下尽管有

实例对象空值的判断，也会产生线程安全的问题，因为多线程是按照时间片来运行线程的，破坏类代码

的垂直执行的顺序，因此加上同步关键字synchronized，使代码块同步，线程安全。*饿汉式因为是在类加载的时候实例化静态类对象，因此无论何时都只有一个静态的全局依赖类对象，

不会有线程的安全问题。

2. java与模式：

简单工厂模式：由工厂和产品类组成，工厂提供实例化之后的对象访问接口，即实例化对象是工厂完成的。*工厂模式：由工厂和产品类组成，只是增加了抽象工厂（父类），具体工厂（子类）以及抽象类（父类）和具体类（子类）。提高了可扩展性

和上面一样，对象是由具体工厂实例化之后生成的。*抽象工厂模式：有工厂和产品类组成，区别是抽象工厂模式可以有多个抽象产品类，以及多个

抽象工厂实例化的产品对象，其他和工厂模式一样。*适配器模式：目标接口：定义要适配的规范方法。适配器：实现目标接口〉被适配者：适配器要依赖的对象，也就是适配器要操作的对象。*生产者与消费者模式：准确说应该是生产者(setter)－消费者(getter)－仓储模型，离开了仓储，生产者消费者模型就显得没有说服

力了。实现代码：

/1. 实体设计：同步栈仓储，共享数据域class SyncStack
/同步栈仓储中的数据产品，默认为10个大小private String[] products=new String[10];/数据产品数据的下标索引，初始化为0private int index=0;
/setter，方法名为push，压栈/同步保证了只有对象只有一个线程占用public synchronized void push(String sst)/如果数据数组的下标递增到10（产品数据中的默认大小）if(index==procucts.length)try/线程阻塞，等待唤醒，释放自己的锁，使其他线程有机会获得/对象的锁wait();
catch(InterruptedException e)/打印错误踪迹e.printStackTrace();
/当数组还未满10个对象时，唤醒在此监视器上等待的单个线程this.notify();/设置
products[index]=sst;
index++;
/getter，方法名为getPro，获取产品数组public String[] getPro()return this.products;
/delete，方法名为pop，弹栈public String pop()if(index==0)try
wait(); 
catch(InterruptedException e)
e.printStackTrace();
this.notify();/获取栈顶的元素
String product=products[index];
index--;return product;

/2. 实体设计：生产者class Producer implements Runnable
/依赖同步栈的数据域private SyncStack stack; /setter，用构造函数进行设置值public Producer(SyncStack stack)this.stack=stack;
/覆写运行的方法public void run()/循环地往数据域里塞值for(int i=0;i<stack.getPro().length;i++)
String product=产品+i;
stack.push(product);
syso（生产了+product);
try /线程睡眠1秒
Thread.sleep(1000);
catch(InterruptedExcetion e)
e.printStackTrace();

/3. 实体设计：消费者
classs Consumer implements Runnable
/依赖同步栈的数据域private SyncStack stack; /setter，用构造函数进行设置值public Consumer(SyncStack stack)this.stack=stack;
/覆写运行的方法public void run()/循环地在数据域弹值for(int i=0;i<stack.getPro().length;i++)
String product=stack.pop();
syso（消费了+product);
try /线程睡眠1秒
Thread.sleep(1000);
catch(InterruptedExcetion e)
e.printStackTrace();

/4. 主方法，轮片调用生产者和消费者线程public class ProCon
/创建数据共享域，即数据的仓储
SyncStack stack=new SynnStack();
/以同步栈即共享数据的仓储为参数创建生产者
Producer producer=new Producer(stack);/以同步栈即共享数据的仓储为参数创建消费者
Consumer consuner=new Consumer(stack);
/创建生产者线程之后使线程为就绪状态new Thread(producer).start();/创建消费者之后使线程为就绪状态new Thread(consumer).start();

3. 静态块： static，可以用于类加载时初始化数据。

4. Java关键字static：类加载时初始化变量，与类有关系。实例化的对象和类都可以调用静态的属性和方法。

5. 实例化和初始化的区别：*1. 实例化是为对象在堆中新分配一个内存空间，在栈中存入新建对象在堆内存中的地址。*2. 而初始化一个对象的意思就是说给新建好的对象的属性赋值，或者是给栈中的原始类型变量赋值都称之为

初始化。

6. 用户注销登录的两种方法：*session.remove(key);/在用户会话中移除键值，即用户的注册信息。说白了就是登录用户实体。

session.invalid();/是用户会话失效

7. 多线程高并发访问时的同步问题：关键字synchronized，有两种同步方式。*原理：同步即是让无序的线程有序，不让cpu按时间片轮回时间地处理请求，效率低。*同步方法

大同小异

在方法的前面加上关键字synchronized即可：public synchronized static int getInstance()

.

*同步代码块〉synchronized(this)/要同步的代码块｝

8. 序列化：*关键字：serializable，用来序列化域实体，是否在用户会话中入库，即服务器重新启动时是否要重新登录。

9. 单点登录(Single sign-on in action)：比较重要

10. 线程的五种状态：创建 就绪 运行 阻塞 销毁

11. 画图设计工具：Rose Rational(IBM) StarUML *用例图 ：给用户看的*类图 ：给程序员看的*时序图 ：项目流程分析*状态图 ：功能点的状态分析

12. 要手动地搞开发，不要完全依赖于工具。

13. 对于Java的jdk，用稳定版本就行了。编译器编译级别为jdk-1的版本。编译级别版本太低不支持java新特性。

14. MD5加密：*导包：commons-codec.jar/加密字符串密码

String passStr=DigestUtils.md5Hex(str);

15. 一个方法代码最好不要超过20行，否则就应该重构。

16. JDBC(Java Date Base Connectivity):Java数据库连接API*伪代码：连接mysql数据库（其中有异常，需要处理）/1.注册驱动，类加载后由静态代码块自动注册驱动class.forName("com.mysql.jdbc.Driver");/2.驱动管理器，打开数据库连接

Connection conn=DriverMangager.getConnection(url,username,pass);/3.得到查询会话
Statement stmt=conn.getStatement();/4.获取查询结果集
ResultSet rs=stmt.executeQuery（查询语句）;/5.显示结果集，用循环操作集合

17. 怎么调用存储过程：Oracle的存储过程，了解即可，用到的地方：金融行业，安全性要求非常高的行业，不会让你轻易

改动数据库表数据的行业，调用存储过程来操作表。

18. 处理异常的过程：可以把编译时异常转换为运行时异常，也可以自定义异常消息。异常不能随便乱抛，会弄乱代码结构

破坏封装性。一般底层的代码抛出异常之后，调用方要及时处理异常，不留隐患。

19。Java特性

封装性：信米非司酮藏

继承：可扩展

多态：可扩展

20. Cookie的结构也是Map，和Session差不多。只是一个存在浏览器客户端，一个存在浏览器服务端。

21. 什么叫面向对象设计：就是把相关性高的一堆代码放在同一个类里面。

22. JSP状态码404是找不到页面错误，这个错误最好解决，看路径是否有错，状态码500页面解析错误，看错误提示调试错误。

23. 重定向和转发*重定向：request.getRequestDispather（路径）.forward(req,res);*转发：response.sendRedirect（路径）.forward(req,res);*二者之间的区别：重定向时请求两次，会丢失第一次请求参数信息的数据和控制器中准备的数据，属于客户端转发。

地址栏会改变地址。转发是请求一次，保留请求参数信息和控制器中准备的数据，属于服务器内部转发。

地址栏的地址不变。

24. 3中编码标准：*GBK：国际编码，表示一个汉字用2个字节。这是中文的编码标准*Unicode：宽字节编码，表示一个汉字用两个字节，这个是JVM（Java虚拟机）的编码标准*UTF-8：表示一个汉字得用3个字节，这个编码标准中文项目用得比较多。这个是中文（也可以是其他语言）文件的

编码标准。

25. 清心寡欲才能把技术学好

26. 只要掌握原理，不要在乎版本。

27. CAS(Central Authentication Service):

28. 宠辱不惊，看庭前花开花落，去留无意，望天上云卷云舒。道家思想，体现了对人生，事物，名利的态度，是一种境界。

29. 多表查询(SQL)：*内连接：获得连个表都有的数据，去除了重复的笛卡尔积，用得比较多。*左外连接：以主表为准，从表没有的记录设置为NULL*右外连接：以从表为准，主表没有的记录设置为NULL

30. 建表时，对于日期字段，可以设置为时间戳，并在映射文件中映射即可。如：

建表字段类型：timestamp default CURRENT_TIMESTAMP；这样保存实体字段数据时就可以省略该字段的设置值。

31. Spring 的核心技术：控制反转和面向切面编程，实现配件的可插拔，其实就是个生产对象的工厂。

32. 一个类的字节码文件只能定义一个公共的类。

33. 抽象类就是用来被继承的，子类系需要实现抽象类中的抽象方法，否则也为抽象类。接口是用来被实现的，

实现人类必须要实现接口中定义声明的方法。接口的耦合度比抽象类低，所以项目中接口用得比较多，是轻量级的，

实现可插拔式编程，自定义自己的实现，提高程序的可扩展性。

34. Java中的转型，有向上转型，和向下转型，向上转型是自动的，向下转型是强制类型的转换，并且要转型的父类对象是

指向子类的实例。

35. Java新特性：反射，class.forName("").newInstance()，用反射会损失程序效率，不过框架中用到很多的反射，特别是

Spring，给一个类，对象工厂就会实例化一个对象。

36. Hibernate中的双向关联和前向关联，是否要设置双向关联还是单向关联，还得看功能界面中的实体关联关系，

是否是双向关联还是单向关联。

37. 依赖关系有全局依赖和局部依赖，全局依赖是对象为类的成员变量，局部依赖比如方法的参数，方法中的变量，作用域

小于全局依赖的成员变量。

38. 项目的MVC设计模式中的模型层中的Service层生成数据，控制层准备数据，显示层显示数据，数据库即是持久化数据。

39. 中断循环：break ：终止当前循环，也就是跳出循环continue：终止当前循环，继续下一次循环。goto：跳出循环，这个关键字Java中省去了，原因是会增加代码复杂度。

2015/8/31

1. 记得保存文档，否则千万后悔。

2. 子程序要操作数据必定会用到依赖，依赖分局部依赖和全局依赖。局部依赖是指方法中的参数，或者方法中的变量。

全局依赖用的很多，比如控制器依赖服务类生成的数据从而准备数据分发到各个页面。

3. 使用接口和抽象类就是为了程序的可扩展性，但是接口更解耦。

4. 抽象就是为了扩展。

5. 编程时刻谨记：可读性 可维护性 可扩展性， 可行性。

6. 请求服务器就是一个设置（setter）并且取值（getter）的过程。

7. 用Map结构可以模拟数据库，一般测试时用的比较多。

8. 对于框架的使用和配置，用注解要比配置文件方便和简洁，但有时还是得用xml配置文件，为了可读性？？看个人

的编程习惯。

9. strut1保存提交表单数据的方式ActionForm，要配置formBean，struts2的方式是模型驱动，用值栈保存，方便好用，

对于有些无法用模型驱动封装的数据可以在动作（Action）中用数据的全局依赖，并提供数据的getter（取值）和setter（设置）

方法。

10. 对于JavaBean这种编程操作数据通过子程序getter和setter方法的模式，在很多地方都有用到，其实setter方法就是初始化

数据对象，而getter就是提供一个供外部访问数据的接口。

11. 初始化和实例化的区别：*初始化：类加载时设置值或者其他方式的设置setter。*实例化：在堆内存中开辟一个内存空间，用于存放数据，在java中就是new（新建）关键字。

12. 编程时最好让变量定义即初始化，可以避免麻烦，特别是C++中的指针，很危险。

13. 项目的编码要统一，必须要从持久化环境中配置数据库编码为utf-8，对于服务器环境不可配置，默认为iso8859-1,

开发环境（编译环境）可配置为utf-8，因为服务器环境你无法左右，所以对于中文参数的get请求，必须要处理编码

问题。对于一般的get请求，参数为中文时，会自动编码后解码，所以你不用utf-8编码后传参数，就会出现乱码问题。

解决方法有，用utf-8编码两次后传参数，在服务端服务器会帮你解一次，你自己必须要解码一次才能真正得到中文的

参数。

对于为什么要用utf-8编码两次，是因为第一次utf-8编码之后的第二次再用utf-8编码，实质上是按照iso8859-1编码，

所以服务器帮你解码时也是按照iso8859-1解码，得到utf-8编码，你自己再用utf-8解码就会得到中文参数。

14. 对于表单POST请求，因为传的参数实在请求体中，服务器不会为你的中文参数iso8859-1编码，所以不会出现中文乱码

问题。我就没有遇到中文乱码问题。

15. Hibernate中的Session和服务器中的Session是不一样的，最好的理解就是前者为会话，后者用户会话，和浏览器有

关，开一个浏览器即开一个用户会话，关闭则销毁。

16. 对于上传文件，因为要传的是大数据类型，所以表单要设置上传文件类型为MIME(Multiple Internate Mail Extensions)

类型：enctype="multipart/form-data".

用来接收文件数据的字段为文件字段：File file，要得到文件名或者是文件类型，命名有规定必须是文件字段名+

FileName得到文件名，文件字段名+ContentType，得到内容类型。

17. 即使是死学也要活用。

18. JDBC操作数据库：

伪代码：conn,stmt,rs 都是资源，用了都需要关闭释放资源，并且这里需要有处理异常。

/1.注册驱动，类加载时注册驱动，这里用到了静态块的代码

Class.forName("com.mysql.jdbc.Driver"); /2.获取连接

Connection conn=DriverManager.getConnection(url,username,pass)://3.获取子句

Statement stmt=conn.createStatement();/4.子句执行查询

ResultSet rs=stmt.executeQuery(sql);

19. Hibernate中也用了大量的反射，效率略低于MyBatis，但Hibernate是全自动化的，MyBatis是半自动化的。

20. 架构师的目标：资源，速度。

21. 反射就是从单纯的类到对象的过程，不依赖new关键字。而使用newInstance()，效率低。

22. 面向对象和面向过程（函数，像C，PASCAL）的最大区别及时到底是以数据为中心，还是以代码为中心，使代码为数据服务，

还是数据去匹配代码。

23. 面向切面编程：切面是由切点和通知组成，切点是由连接点组成，通知要及时在连接点织入的方法。通过在特定的代码中

横切入通知（事务，日志等），达到横向编程的目的，改变人类以前的垂直编程的思维方式。

24. 面向接口编程：定义接口即定义一组方法的声明，规范，用户可以自定义自己的实现，提高程序的可扩展性，而且

解耦。

25. JavaBean的特点，及时定义一个实体，并提供对数据的getter和setter操作方法，setter是设置值，getter是提供

供外部访问的接口，目的就是提高对象的原子性，高度封装。

25. 为了区分HQL语句和SQL语句，推荐写HQL语句时关键字都用大写。hql语句是面向对象的查询语句，表即是对象，

首字母要大写，其他的过滤条件和sql差不多，最大的不同就是如何传播参数。

26. 坏人偿命，好人反而不偿命。

27. sql语句其实也可以理解为请求语句，请求对象为数据库，相比于请求服务器，查询语句用得最多，有多表查询，

子查询，连接查询。

28. 静态包含和动态包含：

静态包含：<%@ include file="" / ，只是把代码片段包含进来，组成jsp页面。*动态包含：<jsp: include file="" / ，是把要包含的代码解析之后再包含进来，组成jsp页面。

29. 表，字段和对象，属性是一一对应的，这样理解更好。

30. 写判断语句的比较条件时，推荐写小于等于或大于等于而不要写大于或小于，这样可以更好地避免越界错误。

31. 最好去找一种好的方案而同时避免引发灾难，而不要试图去找最佳的解决方案。(Lampson 1984)

32. 键值对这样的数据结构模型很多，比如前端的json（java脚本对象表示符号），服务端的属性表文件，Map（映射结构）

其实数据库端的表结构也可以理解为键值对结构，键为列名，值为当前列对应的值。这是一种表示数据对象最轻量级

的方式。

33. 要对如何处理数据充满满满的爱意。

34. 要对编程有感情，把它当作一门艺术来对待。

35. 没学过编程，你就不知道注重细节有多重要。

36. 普通的软件工程实践与最优秀的软件实践差距巨大－－多半比其他的工程学科中的这种差距都要大。因此，传播优秀

实践经验的工具是十分重要的。--Fred Brooks

37. 在编程实践中，可读性这个很重要，可以使代码结构清晰，可以避免少出错。

38. 通过隐式的比较，可以减少让阅读你代码的人要阅读的项数，可以增强可读性。

39. 代码结构复杂了之后就要记得重构。

40. if子句最好要加上else子句，增强代码的逻辑性，如果否则部分的确没有内容可以写个空语句。这样真的好吗？

41. 把否定形式的判断语句改为肯定形式的判断语句，可以增强可读性，又是可读性。

42. 括号很方便，并且能够改善可读性。

43. sql语句的过滤子句的where 1=1 的作用就是为了拼接语句的方便。

2015/9/1

1. 编程中描述数据对象的方式，类型+数据命名字段：* 前端编程：即HTML的标签即类型，编号是名字，类字段也是名字，外加属性需要自己set其值。* 服务端的编程，即java描述方式为：数据类型+体现功能需求的数据命名字段，* 数据库端的编程：配置文件（例如：Hibernte的对象和表的映射文件）的数据对象描述方式和HTML的描述方式大

同小异，数据库表中的列字段推荐和实体对象中的属性相对应，最好不要改什么，因为方便。

sql（create语句）语句中描述数据字段的方式为：数据命名字段+数据字段的类型。

2. 对于判断语句，基本上都是获取（getter）数据之后再做条件的判断。

3. 编程的过程就是对数据操作过程，操作过程分为setter（设置）和getter（取值），遇到需要判断的数据就用条件判断语句

遇到大量的数据用集合或者是数组（内置数据类型，java中不是，也要在堆内存中动态的分配一定的内存空间给用户存储数据）。

再用循环操作数据集合，遍历即是getter（获取数据的过程），存值即时一个setter的过程。

4. sql语句也是一个请求语句，说白了就是和服务器中的Get语句一样是一个setter和getter的过程，就是请求的对象不一样，

一个是数据库，一个是服务器。

5. 一般的项目都会有主从表的表关联，一对多的关系最多，这里之后就会遇到懒加载的问题，XXX.hbm.xml的配置文件中

对于关联关系属性默认就是懒加载（到用到的时候再来加载数据），而加载数据就会用到session，它的生命周期在服务

端（Service，服务层）用完就会销毁，因此在页面再用session加载数据就会楚翔懒加载的异常。

解决的方式就是：有两种方法* 1. Spring框架有一个在视图中打开会话的过滤器，可以延长会话的生命周期到视图的客户端，OpenSessionInViewFilter,

在web.xml中配置即可，至于怎么配置，和其他的过滤器配置方式是一样的。

配置文件代码：<filter>

<filter-name〉过滤器的名字：openSessionInViewFilter</filter-name>

<filter-class>Spring中的过滤器全限定名〈/filter-class>

</filter>

<filter-mapping>

<filter-name〉过滤器的名字〈/filter-name>

<url-pattern〉要过滤的资源〈/url-pattern>

</filter-mapping>

2. 直接在Hibernate的映射文件中的配置关联关系属性的懒加载的值为：假，如：lazy="false"

6. Hibernatge会话工厂的实现类为：org.springframework.orm.hibernate3.LocalSessionFactoryBean

7. 学习框架的一般步骤就是：导包－〉配置－〉使用

8. 对于领导包，要对每个包的作用相当清楚，不能随便地导包，浪费项目的空间。

9，表的更新和插入最大的区别就是，更新就是往数据库表中已存在的数据项重新设置新值，数据项对应的编号已经存在

插入的数据库没有对应的列的编号，如果设置的主键的自动增长，数据库系统就会为插入新数据重新分配一个对应的编号

相同的点就是：都是往数据库中塞值的一个过程。

10. web工程中的每一层多有相对的环境显示层是pageContext，控制器层就是动作环境（ActionContext，解耦的；不解耦

的是ServletActionContext），服务器层的是应用程序环境(ServletContext);

11. 由于你的代码不会像你那么敏锐，因此更好的做法就是用嵌套的判断语句来明确你的用意，而不是要依赖于求值顺序

和短路求职，意思就是说你应该用嵌套的判断代替短路求职或者求职的顺序。

12. 获取ApplicationContext的两种方式* 1. 独立测试时，直接new（新建），资源配置文件为类路径下的配置文件。* 2. 也可以用WebApplicationContextUtils工具类来获取ApplicationContext，例如：

ApplicationContext ac=WebApplicationContextUtils.getWebApplicaitonContext(application);*注：一般项目会有一个ContextLoaderListener监听器，初始化ApplicationContext，并实例化各种Bean对象。

所以对于你配置好的bean对象，Spring工厂会为你反射造好，到时你直接用即可以了。

13. Struts1和Struts2的区别：* 1. 是否有容器依赖性* 2. Action（动作）是否是单例的还是多例的（多例的好处就是不同享同一个数据，每一个行为都有自己的数据域

高迸发的时候也不会出现问题，实现方式是每一个行为用线程变量LocalThread存储每一个行为的数据，

用空间换取时间，增加了内存开销）。* 3. 配置文件不一样* 4. 是否要在web.xml配置文件中配置Action

14. 关于注解和配置文件* 1. 怎么用注解：以Spring中的配置文件来说〉需要配置〈context:scan-component base-package=要扫描的包及子包/

几个注解关键字：Controller（控制器） scope（作用域） Service（服务） Transactional（事务） Depository（仓库） > 1. 会话工厂配置sessionFactory 实现类为org.springframework.orm.hibernte3.LocationSessionFactoryBean

依赖的数据为Hibernate.cfg.xml配置文件configLoacation属性

和数据源：dataSource 实现类（用的是c3p0连接池，这个个连接池较稳定，也可以用其他的连接池）

为com.mchange.v2.c3p0.ComboPooledDataSource> 2. 事务管理器配置：

TransactionManager配置，实现类为org.springframework.orm.hibernate3.HibernateTransactionManager

依赖属性为：会话工厂SessionFactory> 3. 事务注解驱动配置：<tx:annotation-driven transaction-manager=""/

2. 配置文件： 同上，只是控制器(Action)，服务(Service)，Transaction要自己配置，不用注解。 1. 配置事务管理器：同上〉 2. 配置切面通知：

配置文件的写法为：配置事务通知

<tx:advice id="advice" transaction-manager=""〉所依赖的属性
<tx:attributes〉配置切入事务通知的方法
<tx:method name="" propagation="REQUIRED"/
.<tx:method /
</tx:attributes>
</advice>

/ 1. 配置切面

<aop:config〉配置切点
<aop:point-cut id="pointcut" expression="execution(* *.*(.))"/配置通知，切点
<aop:advisor advice-ref="advice" pointcut-ref=""/
</aop:config>

/ 2. 另一种配置切面的方式

<aop:config〉配置切面
<aop:aspect ref=""〉配置后置通知，切点
<aop:after-returning method="" pointcut=""/
.<aop:aspect>
</aop:config>

15. 刷新就是根据URL（地址）重新向服务器发出请求。

16. 项目开发中的Struts.xml 配置文件的一般常量配置：<!-－设置用户界面层的主题模式为简单模式，就是不会自动为你的界面添加特殊的格式－->

<constant name="sturts.ui.theme" value="simple"/

<!-－在项目开发中，设置常量值为开发模式，修改局部方法之后，就可以不用重新启动服务器调试代码了。-->

<constant name="struts.devMode" value="true" /

17. MVC：模型－视图－控制器模式*模型：domain（实体域模型） DAO（数据访问对象） Service（服务），数据模型层.*视图：显示层，jsp,asp等页面，数据的显示层.*控制器：Controller（控制器），数据的分发中心层.

18. Java程序和数据库之间是通过TCP/IP协议交互的。

19. 数据库也是一种服务。

20. 协议既是一种规定，规定用户该做什么。

21. 模块包含层，项目要分层。

22. SOA(Service Oriented Achitechture): 面向服务的架构

23. 多用对象的方法，少用运算符，因为很容易出错，例如：一般来说，Java程序里应该使用像a.equals(b)（比较的是字符串的内容）

这样的表达式，而不要用a==b（比较的是对象的内存地址）.

24. 尽量减少深层嵌套，要么你应该重新设计一个子程序，要么重新设计那部分复杂代码。

25. 实际很少有必要使用case语句。(Meyer 1997)

26. 使用规则性不强的方法所生成的源代码，很难有意义且形象地反应反映出程序是如何在机器上执行的，就是可读性不强。

27. 可读性差意味着不被理解，最终导致程序的低质量。

28. 结构化编程的中心论点是：任何一种控制流都可以用顺序，选择和迭代三种控制结构生成。(Bohm Jacopini 1944)

29. 编程需要比其他任何活动都要专心。

30. 让事情尽量简单，但不能过于简单。--Albert Eubstein

31. 前端：文档流 服务端：控制流 资源流 文件流

32. 编程的首要任务：降低复杂度，增加可读性。

33. 软件的首要技术任务：管理复杂度。

34. 把代码的复杂度降低到最低水平是编写高质量代码的关键。

35. 软件开发到软件工程的形成需要一个过程。

36. 阅读代码可以找出较多的接口缺陷，功能测试可以检测出更多的控制缺陷。

37. 提高代码的可读性，可以减少代码的出错率。

39. 缺陷在代码中存在的时间越长，修正缺陷代码的代价就越高。

40. 尽早地捕捉错误才能有效地节省成本。

41. 编程的数据模型：键值对，数据描述方式：类型名， 数据的操作方式：getter setter delete，

面向对象编程其实就是对一个个javabean对象，增删改查。

42. md5是应用层的加密算法。

43. 世界上没有免费的午餐，就是有，味道也不会好到哪里去。

44. 绝大多数项目的最大规模的一项活动就是调试以及修正那些无法正确工作的代码。

45. 编程的调试和找错是最耗费时间的一个阶段。

46. 把时间投入到前期工作中，能让程序员在后期工作中节省更多的时间。

47. 及时测试工作完成得很有效率，作为完整的质量计划的一部分，复查或者其他类型的协同同样很重要。

48. RMI(Remote Method Inteface)：远程方法接口。

2015/9/2

1. 时间戳，日期，和日历的区别：*TimeStamp时间戳：包含为－>java.sql.精确到时分秒，日期可以转换为时间戳类型，方式为：

TimeStamp date=new TimeStamp(new Date().getTime());*Date日期：包含为－>java.util.精确到日期*Calendar日历：包含－> java.util.包装类，有更丰富的方法

2. 1970年1月1日00:00:00 ：算是Unix 和C语言的生日。主流计算机和操作系统都用它，其他的手机，仪器的时间初始化

也是这个时间，包括Java等高级语言也是这个时间作为Date的初始化时间。

3. Integer.valueOf(str)和Integer.ParseInt(str)的区别：*返回值不一样，valueOf(str)返回值为Integer的实例对象，而parseInt(str)，是把字符串的解析整形。*注：Integer.valueOf(str)中，如果str的整形值不在区间[-127,128]之中，就会新建一个Integer对象并

初始化值。

4. 每过一段时间在就想想自己的过去，你就会觉得自己当初是多么的笨，所以学习，总结就是你不断前进的动力。

5. 内置类型：*整型：byte（1个字节）， shot（两个字节） ，int（4个字节），long（8个字节）*小数型：float（4个字节），double（8个字节）*字符型：char（java中是两个字节）*布尔型：bool（一个字节）*数组：在Java中数据不是基本的内置数据类型，构建时要指定数组的大小，在C中是内置数据类型。*具名常量：在Java中具名常量是用大写的字符串表示的常量整形，

注：在Java中只有前面的8种是内置的基本数据类型。

6. 不常见的数据类型（时代在前进，这些不常见的数据会逐渐地被淘汰，或者是封装成其他的数据类型）：*指针：在java中封装为引用，安全好用。*结构体：其实就是具有关联关系的公有的数据的集合，没有操作数据的子程序，是组合的关系，后面面向对象

编程思维出现之后，演变为类。*全局数据：全局数据其实就是类中公有的数据对象，和类变量（静态变量）的最大区别就是是否是静态的，是否

是类所有。全局数据因为有风险，破坏了数据的封装性，所以最好用访问器子程序来代替对全局变

量的访问。

方法就是：把全局变量改成私有的或者是受保护的数据变量，再增加一个getter和setter的数据的

访问器子程序。

7. 使用全局数据要比使用局部数据的风险要大。

8. 模块化和信米非司酮藏结合使用设计良好的类可能算不上是绝对真理，但他们能极大程度地提升程序的可理解性和可读性。

9. Java中的传值和传引用：*"Java中参数传递都是按值传递，这句话的意思就是说，按值传递是传递值的拷贝，按引用传递的是引用的

地址值，所以统称按值传递。*在Java里面只有基本类型和下面这种定义方式是按值传递，其他的是按引用传递。就是直接用双引号的字符串

定义方式。

10. 要操作数据，必须要有依赖。

11. Java中栈是存放基本数据类型值的，比如对象的地址，整形，堆是存放大对象的，比如字符串String等。在栈中

读取数据比堆中读取数的效率要高。

12. 形参和实参的区别就是是否有给参数赋值。

13. http post 请求的内容类型为：application/x-www-form-urlencoded

分析：内容类型一般分为主流数据格式，资源格式？ 例如：text/javascript（java脚本） image/gif（动态图的MIME类型）

imge/jpeg（jpeg图片的MIME格式） application/msword（doc文档的MIME类型）

14. SOAP(Simple Object Access Protocol)：简单对象访问协议。

15. Java与模式：*代理模式：由目标接口，目标对象，代理对象组成，目标对象和代理对象都实现目标接口，自定义实现

接口中的方法，代理对象依赖目标对象，并调用目标对象实现的目标接口的方法，完成代理

功能。*装饰者模式：由抽象类（或者接口），具体类（被装饰类，继承抽象类或者实现接口），装饰者类继承抽象

类或者实现接口）组成。装饰这类依赖抽象类或者接口，从而动态扩展对象的功能，很抽象。*二者不同：代理类控制被代理类的对象，对其具有控制权，决定其执行或者不 执行。而装饰者模式中，

装饰者类没有对被装饰对象有控制权，只能是增加一层装饰，以增加被装饰对象的功能。

16. WSDL(Web Service Description Language)：网络服务描述语言

17. Java对象的引用：* 强引用：对象不释放内存，jvm内存满了之后就会报异常。* 软引用：如果Java虚拟机的内存不够用了，就会释放对象内存。* 弱引用：检测到对象存在，即释放内存。* 虚引用：随时会释放掉对象的内存。

注：Java虚拟机是根据对象是否存在引用来回收对象的。

18. J2SE的基础是非常重要的。

19，对于要不要写注释的问题，为了代码的可读性，注释还是写得好，类前面的必须要写，方法必须要写，方法里的每个

语句有时间的话还是写写，可增强可读性，但没有强制的要求。

20. 套接字(socket)：有三部分组成，目标IP地址，协议，端口号。

注：地址一般就指的是服务器名，端口号指的就是服务名，协议就指的是文件传输协议。

30. 通过访问器子程序访问类的私有数据，类的实例化对象不能随便地访问类的私有数据，从而提高了数据的封装性，

安全性。

31. 概念模型（实体设计），数据模型（数据库），对象模型(JavaBean)，这三个是数据从需求分析到成为对象模型的一个

过程。

32. TCP(Transmission Control Protocol)：传输控制协议

33. 分层就是为了解耦，每一层完成自己的一项任务，提高项目的可维护性，和可扩展性。

34. Web开发中严格的MVC设计模式：一张表对应一个Action（动作），分发数据到不同的页面。

35. 分层隔离，就是为了实现自动化，层与层之间只提供接口进行通信，目的就是为了解耦。

36. Web开发中的请求过程其实就是提交数据给服务器，然后服务器响应处理数据(setter ,getter,delete)，最后分发

准备好的数据到各自的页面中显示。

2015/9/3

1. Java Web 开发中如何进行分页

分页：思路：JavaBean(PageBean)->Action(UserAction)->Service(HqlHelper)->Jsp

1. 设计实体PageBean（分页之后显示的页面实体类），具体的属性有：当前页(currentPage)，总记录

数(recordCount)，每页显示记录数(pageSize)，总页数(pageCount)，其中总页数(pageCount)=

(recourdCount+pageSize-1)/pageSize；这个公式需要自己理解，还有当前页的记录列表集合

(recordList)，开始页面的索引号(beginPageIndex)，结束页面的索引号(endPageIndex);

2. 操作用户的动作(UserAction)，依赖用户的数据访问对象(UserDao)，获取当前页的数据列表集合

之后放到Action的值栈中，分发到分页的当前页显示该数据集合。

3. 3.1 在服务类中实现方法：protected PageBean getPageBean(int pageNum,HqlHelper hql);3.2 这里涉及一个业务逻辑工具类即HqlHelper（查询语句助手）

4. Jsp页面，见下文

摘要：所用框架为：Hibernate+Spring+Struts2，以分页显示后台用户列表为例1.设计实体：页面类PageBean1.1 分析：

当前页：currentPage（请求数据）

总记录数：recordCount（查数据库：count(*)）

页面大小：pageSize（配置文件设置值）

本页的数据列表：recordList（查询数据库：select *）

总页数：pageCount（计算）=(recordCount+pageSize-1)/pageSize;

开始索引：beginPageIndex（计算）

结束索引：endPageIndex（计算）1.2 代码，这里以显示10个页码索引为例：public class PageBean

private int currentPage;private int recordCount;private int pageSize;private List recordList;
private int pageCount;private int beginPageIndex;private int endPageIndex;
public PageBean(int currentPage,int recordCount,int pageSize,int recordList)/当前页this.currentPage=currentPage;/总记录数this.recordCount=recordCount;/页面大小this.pageSize=pageSize;/当前页的总记录列表this.recordList=recordList;
/计算pageCount：总记录数/这里可以用逻辑判断，如：
/*
if(recordCount%pageSize==0){
 pageCount=recordCount/pageSize; 
}else{
 pageCount=recordCount/pageSize+1;
}*/或者用算法，自己琢磨
pageCount=(recordCount+pageSize-1)/pageSize;
/这里以显示十个页码索引为例，设置开始页码索引和结束页码索引/当页面总数小于10个时if(pageCount<=10)
beginPageIndex=1;
endPageIndex=pageCount;
else/当页面总数大于10个时
beginPageIndex=currentPage-4;
endPageIndex=currentPage+5;
if(beginPageIndex<1)
beginPageIndex=1;
endPageIndex=10;
else if(endPageIndex>pageCount)
beginPageIndex=pageCount-9;
endPageIndex=pageCount;
/Setter和Getterset.
get.

2.设置实体工具类：HqlHelper2.1 分析2.2 代码public class HqlHelper/from子句private String fromClause;/where子句private String whereClause;/排序子句private String orderClause;

/参数集合，Hql语句中where子句中用到的参数对象private List<Object> parameters=new ArrayList<Object>();
/构造函数设置fromClause，默认别名为opublic HqlHelper(Class clazz)this.fromClause="FROM "+clazz.getSimpleName+" o";
/自定义别名public HqlHelper(Class clazz,String alias)this.fromClause="FROM "+clazz.getSimpleName+alias;
/设置where子句的，以及用到的参数对象，这就是查询条件public HqlHelper addCondition(String condition,Object. params)if(whereClause.length()==0)
whereClause=" WHERE "+condition;
else
where+=" AND "+condition;
if(params!=null & params.length>0)for(Object o:params)
parameters.add(0);
return this;
/设置是否追加，这个接口留给用户，到时方便用户开发public HqlHelper addCondition(boolean append,String condition,Object. params)if(append)
addCondition(condition,params);
return this;
/设置排序条件子句public HqlHelper addOrder(String propertityName,boolean isAsc)if(orderClause!=null & orderClause.length()>0)
orderClause=" ORDER BY "+propertityName+(isAsc?" ASC":" DESC");
else
orderClause+=", "+popertityName+(isAsc?" ASC":" DESC");
return this;
/这个增加了是否追加排序条件子句public HqlHelper addOrder(boolean append ,String propertityName,boolean isAsc)if(append)
addOrder(propertityName,isAsc);
return this;
/得到查询子句hqlpublic String getQueryListHql()return fromClause+whereClause+orderClause;
/计数hqlpublic String getCountHql()return "SELECT COUNT(*) "+fromClause+whereClause;
/参数集合get接口，供外部访问public List<Object> getParameters()return parameters;
/这里只要两个参数，跳转的页面，和继承了BaseDao（自己抽取的接口，很有用的）的servicepublic HqlHelper buildPageBeanForStruts2(int pageNum,BaseDao<? service)
PageBean pageBean=service.getBean(pageNum,this);
ActionContext.getContext.getValueStack.push(pageBean);return this;
3.设计service，这里把方法放到BaseDao中，service继承即可：3.1 代码/事务注解（需在Spring中配置，TransactionManager）@Transactionalpublic class BaseDaoImpl<T> implements BaseDao<T>这里需要配置SessionFactory在Spring容器中，自己配不难/这个是注解，相当于Setter@Resourceprivate SessionFactory sessionFactory;/实体类型protected Class<T> clazz;
/在构造函数中进行初始化clazzpublic BaseDaoImpl()
ParameterirzedType pt=(ParameterizedType)this.getClass().getGenericSuperclass();this.clazz=(Class)pt.getActualTypeArguments()[0];
/获取Session，方便操作数据库protected Session getSession()return sessionFactory.getCurrentSession();
public PageBean getBean(int pageNum,HqlHelper hqlHelper)
/参数集合private List<Object> parameters=hqlHelper.getParameters();/配置的页面大小private int pageSize=Configuration.getPageSize();
/recordCount，总记录数
Query countQuery=getSession().createQuery(HqlHelper.getCountHql());if(parameters!=null & parameters.size()>0)for(int i=0;i<parameters.size();i++)
countQuery.setParameter(i,parameters.get(i));
Long recordCount=(Long)countQuery.uniqueResult();
/recordList，当前页的记录列表
Query listQuery=getSession().createQuery(HqlHelper.getQueryListHql());/设置查询参数if(parameters!=null & parameters.size()>0)for(int i=0;i<parameters.size;i++)
listQuery.setParameter(i,parameters.get(i));
/获取当前页的记录
listQuery.setFirstResutl(pageSize*(pageNum-1));
listQuery.setMaxResults(pageSize);
List recordList=listQuery.list();
return new PageBean(pageNum,recordCount.intValue(),pageSize,recordList);

4.设计Action：以UserAction为例4.1 代码：顺带把配置加上，交给Spring容器管理@Controller

@Scope("prototype")public class UserAction extends ActionSupport
private int pageNum;
get. set.;
@Resourceprivate UserService userService;
/用户数据列表，分页显示public String list()new HqlHelper(User.class,"u")/buildPageBeanForStruts2(pageNum,userService);

5.页面：设计一个公共页面 pageView.jspf，通用的

代码：<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<div id=PageSelectorBar>
<div id=PageSelectorMemo>
页次：${currentPage}/$pageCount｝页 每页显示：$pageSize｝条 总记录数：$recordCount｝条〈/div>
<div id=PageSelectorSelectorArea>
<a href="javascript:gotoPage(1)" title=首页 style="cursor: hand;">
<img src="${pageContext.request.contextPath}/style/blue/images/pageSelector/firstPage.png" / 
</a>
<s:iterator begin="%{beginPageIndex}" end="%{endPageIndex}" var="num">
<s:if test="currentPage==#num">
<%-－当前页 --%>
<span class="PageSelectorNum PageSelectorSelected">${num}</span>
</s:if>
<s:else>
<%-－非当前页 --%>
<span class="PageSelectorNum" style="cursor: hand;" onClick="gotoPage(${num});">${num}</span>
</s:else>
</s:iterator>
<a href="javascript:gotoPage(${pageCount})" title=尾页 style="cursor: hand;"> <img
src="${pageContext.request.contextPath}/style/blue/images/pageSelector/lastPage.png" / </a> 转到：<select id="pn" onchange="gotoPage(this.value)">
<s:iterator begin="1" end="%{pageCount}" var="num">
<option value="${num}">
${num}</option>
</s:iterator>
</select>
<script type="text/javascript"〉回显页码
$("#pn").val(${currentPage});</script>
</div>
</div>
<script type="text/javascript">
function gotoPage(pageNum){/window.location.href="topicAction_show.action?id=${id}&pageNum="+pageNum;
$(document.forms[0]).append("<input type='hidden' name='pageNum' value='"+pageNum+"'/");
document.forms[0].submit();/提交表单  }</script>

2. NoSQL：

3. 安装项目的过程步骤：如何部署一个项目* 创建数据库，并初始化数据库。* 把项目部署到服务器中。* 测试运行。

4. 简历的重点在项目经验，一定要熟悉你写的项目，做到烂熟于心。

5. 面试笔试题，老师说要做到2000道，才算过关。

6. 常见的Java笔试题，分析。

Action的execute方法中不返回ActionFoward对象，而是返回null，将会有什么结果？什么情况有这种应用？

（文件下载）

设计模式的讲解。*sql关联查询的讲解。*hibernate二级缓存的讲解。*数据库的存储过程和触发器也是经常被问到的问题。*weblogic的使用。*必须能够独立写出数据库分页代码

7. 对于项目经验，包括项目名称，项目描述，责任描述，技术描述。项目名称为客户名+项目名称。项目描述所要说的就

是你为谁开发的项目，项目的作用，功能，项目包含的模块，简洁明了，3行左右就可以了。责任描述就是你在该项目

中负责的模块，以及工作职责，可以带过。重要的就是技术描述，面试官要问的地方就在项目的功能点，技术点，最好

写清楚使用什么技术，实现了什么功能，至于怎么实现的，就是你面试时要说的。

8. 修改虚拟主机的文件夹路径为：C:WINDOWS\system32\drivers\etc

9. WINDOWS盘符和文件夹使用：分隔 的，网络路径中协议和主机名使用：//分隔的。注：1. 在Windows中物理路径是由\分隔的，网络路径是由/分隔的，Linux中都是用/作为分隔符。

2. 在Window操作系统中字符是不区分大小写的，就像百度搜索时的字符也是不区分大小写的。

10. 安装好jdk(Java Develop Tookit):Java开发工具箱之后，配置：*1. 配置JAVA_HOME（Java开发工具箱的安装目录）: jdk的安装路径。*2. 配置CLASSPATH（Java类的搜索路径）: .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar;%JAVA_HOME%\lib\dt.jar。*3. 配置PATH（命令搜索的路径）： %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;。

11. tomcat是一个调试容器，真正部署项目的时候大多使用WebLogic或者WebSphere，在其中部署10个项目就会跑得很慢

了，建议改用其他的web容器，如：WebLogic。

12. 初级学知识，高级学规律。

13. 程序员的面试中的自我介绍：（以谈技术为核心，两分钟就行，踏实点，说重点，尽快切入主题）

1. 你是谁（有名字就行）*2. 你要应聘的职位（Java软件开发工程师）*3. 你以前做过什么项目（做过什么）*4. 你擅长的技术（能做什么）*5. 适当地吹牛皮（少吹点，能不吹就不吹）

注：面试官最想知道的就是你到底具体不具备软件开发能力，沟通能力，从而觉得要不要找你。

14. 对于校招，可以适当地写两个项目就行了，不可能有太多的项目经验，工作经验也可不写，因为应届生哪有那么多的工作

经验；对于社招，那就要适当的包装自己，至少2年工作经验，3个项目最适合，重要的项目放在前面。

15. 把老师教给你的项目内化成自己的项目，一定要对象项目中用到的技术熟悉，熟悉，再熟悉，前提是你要有深入才能

简出。

16. 前端编程经验的总结：功能界面设计，涉及的技术有前端的CSS+DIV布局，以前布局使用表格，框架，现在布局基本上

使用区块的浮动布局。

功能界面实际的一般思路是：1. 首先是要有项目的需求分析，完成需求说明的文档，这个部分由需求分析师是完成。2. 功能界面的设计，这部分由美工和网站策划师完成。3. 前端工程师完成功能界面的实现，必须分毫不差地实现美工的效果。4. 布局完成，渲染完成之后，即可以为表单添加特效，校验及其他的特效等，也就是

前端工程师的脚本编程。5. 有些异步请求的校验，以及需要用异步请求完成的功能可以是由服务端工程师完成。

注：对于CSS+DIV的布局：

有一般的规律可循：*1. 搭建结构，用HTML标签元素搭建文档的结构*2. 添加图片，文件等内容*3. 给标签元素命名，有利于层叠样式表给特定标签元素的渲染〉类别命名一般用于层叠样式表选择使用〉标号命名一般用户Js编程加特效

注：这里说的是一般，也可以混用，

命名习惯：

#1. 类别命名可以使用标签类型+功能名字的方法

#2. 编号命名根据需要或者是需求命名

注：这里还是得听项目经理的*4. 给标签的样式表塞值（填表单）：

塞值步骤可以是（个人经验）：

#前提： 可以有公共通用的层叠样式表的塞值文件：*commons.css可以设置属性，如所有标签

或者是文件中用到的标签内外边距为0，图

片的边框大小为0px，锚标记的字体大小。

颜色，访问样式的设置，如：

text-decoration,a:visited,a:hover,

a:link,a:active

剩下通用字体的设置等等。

#1. width（宽度） height（高度）

#2. line-hight（行高） text-align/vertical-algin

（文本的对齐方式）

是水平对齐还是垂直对齐。

#3. 字体的设置：font-size（字体大小） font-weight

（字体粗细）

color（字体颜色）

注：层叠样式表也支持继承，说白了就是就近原则

复写的原则。

#4. 背景图片，背景色：background,background-color

#5. 内边距 边框 外边距：

padding border margin

#6. 最后就是布局：是区块元素或者内嵌区块元素就要

布局，float（浮动布局）,relative, absolute

overflow等

#7. 特殊的层叠样式表的塞值：*1. left=-1px；左位移*2. bottom=-1px；相邻元素向上位移*3. z-index=0；层叠权限级别17. Js编程经验总结：脚本编程用到的最多的就是Java脚本库：JQuery，封装了Java脚本编程中对元素的选择方法，Java脚

本编程的操作对象是DOM(Document Object Model)元素：文档对象模型，是基于事件响应的编程，其中用到了许多的回

调函数即函数指针的调用，通过传递函数对象（很多的匿名函数），局部依赖方法，完成相应的功能。说简单点，其实脚

本编程其实就是选择标签元素后，对标签元素的属性的设置值，移除值，以及对其层叠样式表属性的设置或移除值，对

其文本内容的getter,setter以及对标签元素的getter delete等等，从而对DOM元素添加特效。

18. 异步请求：JQuery的异步请求方式，有6种常用的方法，

注：Js的对象表示方式可以是重量级的xml文件，或者是轻量级的json数据表示方式（字符串键，对象值）*1. $.ajax(/请求的地址

url:""，异步请求要提交的参数data:{}，是否异步请求

async:true/false，是否缓存

cache:true/false，异步的请求方式

type:"POST"，传输的数据类型

dataType:"json",

/异步请求成功之后要调用的函数，result是异步请求的服务端方法成功之后的返回值success:function(result)

.

);/url：为你要请求访问服务器地址，data为你要提交的参数，function 为异步请求成功之后要执行的函数

2. $.post(url,data,function);*3. $.get(url,data,function);*4. $.load(url,data,function);/不管请求成功或者失败，都会执行回调函数。

5. $.getJSON(url,data,function);*6. $.getScript(url,fuction)

19.EL表达式：*EL表达式中判断对象值是否为空的方式： $empty 值｝*EL表达式中判断对象值是否相等的方式：1. eq 一般选用这个，比较字符串不需要用双引号。2. == 这个也可以用

21. 伪协议：href="javascript:"，超链接后为执行javascript类型的方法。

22. <c:out value="" /是jstl标签库中提供的数据输出功能，$｝是J2EE中提供的数据输出功能，两者完成的效果一样。

23. el表达式一般不直接用==判断是否相等， < >= <= !=之类的表示大于，小于，大于等于，小于等于， 不等于，而是

使用字母的表达式，eq，ne,gt,lt,ge,le，字符串比较，不需要使用”。

24. js方式的异步请求：有的企业要求你要会写，*1. 异步请求的get方式

代码：创建一个XmlHttpRequest请求function createXmlHttpRequest()/声明一个请求，并是设置为空

var xhr=null;try/兼容IE浏览器的请求
xhr=new ActiveXObject("microsoft.xmlhttp");
catch(e)try/其他浏览器的请求对象
xhr=new XmlHttpRequest();
catch(e)
alert（你的浏览器太差！");
/返回请求return xhr;
/创建异步get请求，在窗口的加载的时候执行函数
window.onload=function()
/界面元素的单击事件之后完成异步请求
document.getElementById("").onclick=function()/获取请求对象，局部依赖该对象
var xhr=createXmlHttpRequest();/请求对象的get请求
xhr.open("get",url);/请求对象发送数据为空
xhr.send(null);/请求对象的请求完之后的分发的数据/请求对象的准备状态的改变事件之后执行函数
xhr.onreadystatechange=function()/请求对象的准备状态为4时，请求成功if(xhr.readyState==4)/请求状态为200或者304时请求成功if(xhr.status==200 || xhr.status==304)/获取服务器响应过来的数据
var data=xhr.responseText;
alert(data);
*2. 异步请求的post方式/1. 创建请求对象，同步，略
/2. 窗口加载的时候，创建异步请求
window.onload=function()/创建请求对象
var xhr=createXmlHttpRequest();/界面元素单击之后的响应
docuemnt.getElementById("").onclick=function()/请求完成之后服务器响应的数据
xhr.onreadystatechange=function()/请求对象的准备状态为4时，响应成功if(xhr.readyState==4)/请求状态为200或者304时请求成功if(xhr.status==200 || xhr.status==304)/获取服务器响应过来的数据
var data=xhr.responseText;
alert(data);
/请求对象向服务器请求数据
xhr.open("post",url);/设置请求体的数据编码方式
xhr.setRequestHeader("content-type","application/x-www-urlencoded");/请求对象向服务器发送数据，paramter是向服务器提交的参数xhr.send(parameter);

26. xml和json都是表示数据的格式，xml是重量级的，操作性强，可以操作xml的各个节点，而json是轻量级的，是Javascript

对象表示符号，本质就是一个键值对，没有像xml一样描述数据的节点，所以xml多数用户配置未见，json就是经常用于

传输数据，提交数据，返回数据，轻量级，效率高。

27. web1.0就是各大门户网站兴起的时代，用户是被动接受者，web2.0 就是网络交互软件的兴起，比如社交软件的风靡，

网络的内容用户自己创建，是主动创建者，web3.0 时代我猜就是物联网时代，这个还需要研究。

28. 页面出现404错误是找不到资源页面，出现500错误是服务器解析错误，出现302是页面地址重定向，101是服务器接

收到请求，200是请求成功。

29. JQuey插件

jquery_treeview：树形视图（有点像手风琴式的下拉菜单，这也是一个Js插件）*学习思路：导包（JQuery基础包，插件包） -〉配置－〉使用〉1. 导包：*1. jquery.treeview.css（JQuery的树形视图的层叠样式表单渲染文件）*2. jquery-1.7.min.js（JQuery的基础脚本文件）*3. jquery.treeview.js（JQuery的树形视图脚本文件）>2. 配置，使树形视图只有一项父目录为展开的，初始化为都不展开*1. 自定义的配置：就是不太好理解/为网页文档添加脚本代码
<script type="text/javascript"〉父目录的单击事件之后执行调用函数
$("").click(function()
/*
目的是选择被单击的父目录节点的其他节点，并隐藏之*/$(this)，表示当前被选择的节点
$("").not($(this).next)).hide();/被单击的父目录执行切换的效果
$(this).next().toggle();
);</script>
2. 配置属性：为了可读性，最好用这种配置的方式
注：$(function(){})；和$(document).ready(function(){});
的意思是一样的，都是在当前文档加载完之后，执行要调用的方法。
$(function()
/选择要显示为树形视图的根，一般为无序列表使用树形/视图的插件$().treeview(function()/配置树形视图的父目录是否锁紧，就是说初始化为不显示/树形视图的子目录，只显示父目录
collapsed:true, /配置只显示一个父目录为可以展开的
unique:true
);
);

jquery_validate：验证框架这称个是前端校验，也可以称作用假的校验，可以骗骗小白用户，前端的代码因为

用户是可以看到的，所以安全性不高，对于服务端的业务逻辑代码，是编译之后的字节码文件

部署到服务器上之后，安全性较高，所以服务端的校验是最安全的校验。但是为了用户体验，

前端的校验还是必须的。1. 导包〉1. JQuery库基础包：jquery-1.7.min.js

注：*开发中也可以用jquery.js，但是发布的版本最好用压缩版本，占用的服务器内存小。*版本的话可以用稳定的版本，不一定最新版的就是最好的，就像开发工具一样用稳定版本的

但是有的插件就是有其版本的要求，比如下面的插件自动补全插件就要求JQuery库版本的号

就是1.7以上的。2. jquery.metadata.js>3. jquery.validate.js2. 配置：这里的配置使用json的数据格式塞值，其实就是初始化，有模板代码如下，可以不用记，知道

用就行。

jQuery.extendjQuery.validator.messages,/必需的字段，这个用得比较多
required:""，验证失败，验证码？？
remote:""，是否是网络地址格式
url:""，是否是邮件地址格式，用得较多
email:""，是否是日期格式
date:""，是否是数字格式
number:""，是否是整数格式
digits:""，是否是信用卡号格式
creditcard:""，两次输入是否相等
equalTo:""，指定后缀名的字符串
accept:""，输入字符最大长度
maxLength:jQuery.validator.format("")，输入字符最小长度
minLength:jQuery.validator.format("")，输入字符长度在｛0｝和｛1｝的值
maxRangeLength:jQuery.validator.format("")，输入值在｛0｝和｛1｝的值
minRangeLength:jQuery.validator.format("")，输入一个最大值｛0｝的值
max:jQuery.validator.format("")，输入一个最小值为｛1｝的值
min:jQuery.validator.format(""),
);
3. 使用：*1. 
$(function()
$("form").validate();
);

2. 用json的数据格式，例如：<input css="{required:true,accept:'.zip'}" /

注：$(function(){})；是$("document").ready(function(){})；的简写，这里用到了函数的回调。

jquery_autocomplete：自动补全1. 到包*1. 导层叠样式表文件：jquery.autocomplete.css>main.css>thickbox.css

2. 导jQuery的基础脚本文件：jquery-1.7.min.js*3. 导自动补全的框架脚本文件：jquery.autocomplete.js

注：一定先导基础的jQuery脚本文件，再导插件脚本文件，顺序出错程序就会无法运行。2. 配置

样例代码：选择要进行自动补全的元素（一般是输入框）

$("#.").autocomplete(url/data，自动补全插件的配置｛/1. 触发自动补全最小字符数(minChars)

minChars:1,2. 下拉列表支持的最大数量(max)

max:10, /3. 下拉列表宽度，默认与文本框同宽(width)width:auto,4. 支持包含匹配(matchContains)

matchContains:true,5. 下拉列表的高度(scrollHeight)

scrollHeight:180,6. 触发自动补全的延迟毫秒数

delay:1000,7. 下拉列表显示的数据，格式化项(formatItem)，局部依赖为要在/下拉列表一行中显示的数据formatItem:function(row)return "<div>"+row.word+"<span>"+row.count+"</span></div>"

，8. 如何解析词汇，生成要显示的数据data，以及选择下拉列表项之/后要显示在输入框中的数据result ，依赖后台返回的json格式数据，是键值对模型parse:function(data)

return $.map(data,function(temp)return /要显示在下拉列表中的数据对象data:temp，要显示在输入框中的值result:temp.word

);

/自动补全选择列表项之后要执行的方法，数据依赖是事件和传入的数据项对象 ).result(function(event,item)

location.href=url+要提交的参数；

);

3. 使用： 如上

fckeditor：富文本编辑器1. 导包：把开发包到导入就行了。fckeditor.js2. 配置：*1. 这里可以自定义文件myconfig.js配置富文本编辑器需要显示的工具栏选项，再在fckcon-

fig.js文件中引用就行了，这里就省去了配置。*2. 使用配置〉样例代码：初始化文本编辑器$(function()/1. 提交表单时本字段使用的参数名，就是要提交的编辑器里的内容content字段

var oFCKeditor=new FCKeditor("content");/2. 指定编辑器文件夹所在的路径，一定要以/结尾，这个必须要有

oFCKeditor.basePath="${pageContext.request.contextPath}/fckeditor/";/3. 指定编辑器的高度

oFCKeditor.height="";/4. 指定编辑器的宽度

oFCKeditor.width="";/5. 指定编辑器的工具栏集合

oFCKeditor.ToolbarSets="";/6. 替换文本域，我还是不太理解，是不是用编辑器的文本域替换/html文档字段里的内容字段？？oFCKeditor.ReplaceTextarea();

);

3. 使用：在要使用文本编辑器的文本域字段用name属性关联配置定义的字段名content

例如：对象图导航语言，struts标签〈s:textarea name="content"></s:textarea>

注：把对象框架的配置初始化理解为填表单就不会那么不好难了。 30. JQuery的元素选择方法：*1. next(); 当前节点的同级下一个节点。*2. siblings(); 当前节点的同级兄弟节点集合。*3. prev(); 当前节点的同级前一个节点。*4. parents(); 当前节点的所有父亲节点集合：可以加上过滤器条件例如：$(this).parents(tr:first)*5. parent(); 获取当前节点的父亲节点。*6. children(); 当前节点的孩子节点集合。*7. not(); 就是排除该节点，例如：$().not($(this).next())；意思就是说排除当前节点的下一个节点。*8. find(); 查找并获取特定名字的子元素节点，可以用选择器来表示，例如：$(div .class);*9. filter(); 查找的是指定名字的同级元素节点。

31. JQuery选择元素之后的操作对象：元素节点，属性，层叠样式表的属性，文档标签内嵌的内容。

32. 作为少年更要珍惜时间。

33. 伪协议的作用：用在锚标记的超链接上，使超链接之后执行java脚本的函数。