//第一种方式,冒充对象的方式.(利用js里的每一个方法名都是一个Function对象)
function Parent(username){
	this.username = username;
	this.say = function(){
		alert(this.username);
	}
}

function Child(username,password){
	
	this.temp = Parent;//temp指向Parent所指向的地方 。 利用js里的每一个方法名都是一个Function对象,指向一个方法。
	this.temp(username);//初始化方法里的内容
	delete this.temp;//temp没有用了。可以直接删除掉.this不可以丢了
	
	
	//Parent(username);//这样写表面看起来是正确的，其实是错误的。因为只有new出来的对象才有this,所以调用Parent里的this就没有值了
	
	
	this.password = password;
	this.hello = function(){
		alert(this.password);
	}
}

var parent = new Parent("zhangsan");
parent.say();//zhangsan

var child = new Child("lisi","123456");
child.say();//lisi
child.hello();//123456

//call()函数是Function对象的一个函数
//具体用法如 
function test(str){
	alert(this.username + ","  + str);
}

var o = new Object();
o.username = "zhangsan";
test.call(o,"123456");//zhangsan,123456 .因为每个Function 对象都有一个call()方法，而函数名就是一个Function对象.call()函数的第一个参数是test函数里的this.

function Parent(username){
	this.username = username;
	this.say = function(){
		alert(this.username);
	}
}
function Child(username,password){
	Parent.call(this,username);
	this.password = password;
	this.hello = function(){
		alert(this.password);
	}
}
var parent = new Parent("zhangsan");
parent.say();//zhangsan

var child = new Child("lisi","123456");
child.say();//lisi
child.hello();//123456

//第三种实现方式:apply()函数方式，apply()和call()是一样的，只不过参数传递不同而已,apply的参数为数组
//所以继承可以这样实现

function Parent(username){
	this.username = username;
	this.say = function(){
		alert(this.username);
	}
}
function Child(username,password){
	Parent.apply(this,new Array(username));
	this.password = password;
	this.hello = function(){
		alert(this.password);
	}
}
var parent = new Parent("zhangsan");
parent.say();//zhangsan

var child = new Child("lisi","123456");
child.say();//lisi
child.hello();//123456

//原型链实现继承
function Parent(){
}
Parent.prototype.hello = "hello";
Parent.prototype.sayHello = function(){
	alert(this.hello);
}

function Child (){
}
Child.prototype = new Parent();//关键

Child.prototype.world = "world";
Child.prototype.sayWorld = function(){
	alert(this.world);
}

var child = new Child();
child.sayHello();
child.sayWorld();

//混合模式实现继承
function Parent(hello){
	this.hello = hello;
}
Parent.prototype.sayHello = function(){
	alert(this.hello);
}

function Child(hello,world){
	this.world = world;
	Parent.call(this,hello);//关键

}
Child.prototype = new Parent(); //关键
Child.prototype.sayWorld = function(){
	alert(this.world);
}

var child = new Child("hello","world");
child.sayHello();
child.sayWorld();

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

//构造方式定义类，优点:多个实例对象不共享类的属性值，缺点:每个实例对象都会产生出一个函数say
function User(){
	this.username = "zhangsan";//this.不能丢
	
	this.say = function(){//this.不能丢
		alert("username:" + this.username );//this.不能丢
	}
	//下面注释的这种写法不对
//	function say(){
//		alert("username:" + this.username );
//	}
}

var user = new User();
user.username = "lisi";
user.say();//username:lisi

var user1 = new User();
user1.say();//username:zhangsan,不受user对象的影响

//多个实例对象不共享类的属性值，如下:
function User(){
	this.username = new Array();//this.不能丢
	
	this.say = function(){//this.不能丢
		alert("username:" + this.username );//this.不能丢
	}
}

var user = new User();
user.username.push("zhangsan");
user.say();//username:zhangsan

var user1 = new User();
user1.say();//user1的username为空，不为zhangsan,因为user1的属性值不受user影响

//原型方式定义类,缺点:类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享
function User(){
}
User.prototype.username = "zhangsan";
User.prototype.say = function(){
	alert("username: " + this.username );
}

var user = new User();
user.username = "lisi";
user.say();//username:lisi

var user1 = new User();
user1.say();//username:zhangsan

//类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享,如下
function User(){
}
User.prototype.username = new Array();
User.prototype.say = function(){
	alert("username: " + this.username );
}

var user = new User();
user.username.push("zhangsan") ;
user.say();//username:zhangsan

var user1 = new User();
user1.say();//username:zhangsan,因为user1属性也会受到user的影响，user1和user指向同一引用，即共享同一属性

//构造和原型结合方式创建类:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享;缺点:属性和方法分开定义不是太好。
function User(){
	this.username = "zhangsan";
}
User.prototype.say = function(){
	alert("username: " + this.username );
}
var user = new User();
alert(user.username);

////动态的原型方式:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享,同时属性和方法不是分开定义的

function User(){
	this.username = "zhangsan";
	
	if(typeof User.flag == "undefined"){
		alert("execute...");
		User.prototype.say = function(){
			alert("username: " + this.username );
		}
		
		User.flag = true;
	}
}

var user1 = new User();//execute...
var user2 = new User();//不会打印出execute...，则说明方法只创建了一次，即方法只会产生一个
user1.say();//username

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

//数组定义，第一种定义方式
var arr = new Array();
//数组赋值
arr.push(1);
arr.push(2);
arr[2] = 3;
alert(arr.length);//3

//第二种定义方式
var arr1 = [];
arr1.push(1);
arr1.push(2);
arr1[2] = 3;
alert(arr1.length);//3

//第三种定义方式
var arr2 = [1,2,3,4,5];
arr2[5] = 6;
alert(arr2.length);//6


//数组排序sort()方法
var arr3 = [1,4,2];
arr3.sort();
alert(arr3);//1,2,4

//
var arr3 = [1,4,23];
arr3.sort();
alert(arr3);//1,23,4  顺序不对的原因是因为js里排序会先转换为字符串，再根据ascii码进行排序。所以23排在了4的前面

// 
function compare(num1,num2)
{
	//因为排序前都转化成了字符串，所以要给parse成int,可以用函数parseInt()函数
     var temp1 = parseInt(num1);
     var temp2 = parseInt(num2);
     if(temp1 < temp2)
     {
     	return -1;
     }else if(temp1 == temp2){
     	return 0;
     }else{
     	return 1;
     }
}

var arr4 = [1,4,23];
arr4.sort(compare);//1,4,23 因为通过自定义函数compare进行了转换
alert(arr4);

User = function (){
}
User.prototype.name = "zhangsan";
//User.name = "zhangsan";//错误定义
		
var u = new User();
u.password = "123456";
//u.prototype.password = "987654";//错误定义
alert(u.name);
alert(u.password);

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

//Extjs里的事件处理,只有继承了Ext.util.Observable类才具有事件功能

Employee = function(){
	this.addEvents("test");//注册事件,该事件名字为：test
}

Ext.extend(Employee,Ext.util.Observable);

todo = function(){
	alert("event was fired");
}

var em = new Employee();
em.on("test",todo);//将方法绑定到事件test上
em.fireEvent("test");//触发事件test

<input type="button" name="button1" id="button1" value="button1" />

todo = function(){
	alert("event was fired");
}

//window.onload = function(){}等价于Ext.onReady(function(){});页面加载完后就执行该函数
Ext.onReady(function() {
		//返回的button1是Observable的子类，所以具有事件处理功能
		var button1 = Ext.get("button1");//返回的Element对象,不等价于document.getElementById("button1")
//		var button1 = Ext.getDom("button1");//返回的HTMLElement对象,等价于document.getElementById("button1");
		
		alert(button1.id);//button1
		
//		button1.addListener("click",todo);//addListener与on是一样
//		button1.addListener("mouseover",todo);
		
		
		//通过EventManager来实现
		Ext.EventManager.addListener(button1,"click",todo);
		Ext.EventManager.addListener(button1,"mouseover",todo);
		
	}
)

todo = function(){
	alert(this.id);//此处的this由addListener的第3个参数决定
}


Ext.onReady(function() {
		//返回的button1是Observable的子类，所以具有事件处理功能
		var button1 = Ext.get("button1");
		
		//先打印出button1,再打印出ext-gen1,刚好与addListener添加的顺序相反
		button1.addListener("click",todo,this);//todo函数打印出:ext-gen1
		button1.addListener("click",todo,button1);//todo函数打印出:button1
	}
)

todo = function(){
	alert(this.id);//此处的this由addListener的第3个参数决定
}
Ext.onReady(function(){
		var button1 = Ext.get("button1");
		//addListener的第4个参数是个配置选项，所以需要用{},有4个配置选项，delay(触发事件多久后执行指定的函数),scope(如果第3个参数设置了,此处可以省),single(事件触发一次后，就被移走，以后再触发该事件无效),buffer（缓存区，也就是多长时间内触发该事件大于1次都认为是1次）
		//delay和buffer同时使用时有错误，具体原因还不知道是为什么?
		button1.addListener("click",todo,button1,{delay:3000,single:false});//因为button1也属于Observable类的子类，所以查看文档时可以直接查看Observable中的addListener方法
	}
)

//window.onload = function(){}等价于Ext.onReady(function(){});  页面加载完后就执行该函数
Ext.onReady(function(){
		alert("ok1");
		function AA(){
			alert("ok2");
		}
	}
)
//只会打印出ok1,ok2不会被打印出来。因为页面加载完后会去执行函数function()，但是function()函数里的函数(或叫类)AA则不会去执行的。

Ext.onReady(function(){
		alert("ok1");
		function AA(){
			alert("ok2");
		}
		new AA();
	}
)

//这样ok1和ok2都会被打印出来，因为new AA()去调用了

todo = function(){
	alert(this.id);//此处的this由addListener的第3个参数决定
}
Ext.onReady(function(){
		var button1 = Ext.get("button1");
		
		//第一种写法
//		button1.addListener("click",todo,button1);
//		button1.addListener("mouseover",todo,button1);
		
		//第二种写法
//		button1.on({click:todo,mouseover:todo,scope:button1});

		//第三种写法
		button1.on(
			{
				click:{scope:button1,delay:3000,fn:todo},
				mouseover:{scope:button1,delay:1000,fn:todo}
			}
		);
		
		
		
	}
)

Ext.onReady(
	function(){
		alert("ok1");//ok1
		AA = function(){
			alert("ok2");//ok2		
		};
		//同时定义多个属性和方法
		AA.prototype = {
			aa:1,
			bb:2,
			a:function(){
				alert("aa");//因为没有调用，所以不会打印出来
			},
			b:function(){
				alert("bb");//因为没有调用，所以不会打印出来
			}
		}
		new AA();
		
	}
)

Ext.onReady(function(){
	var win = new Ext.Window({
		title:'hello',
		html:'world',
		width:400,
		height:300
	});
	win.show();
	//查看Extjs的文档：Ext.Window中的Public Events部分查看到:move : ( Ext.Component this, Number x, Number y ) ,默认3个参数，所以才有得下面函数的c,x,y
	win.on("move",moving);
})

moving = function(c,x,y){
	alert(c.id);
	alert(x);
	alert(y);
}

<a href="http://www.baidu.com" id="baidu">百度</a>

//事件处理EventObject

todo = function(e){//EventObject,在这里可以理解为：EventObject是HTMLElement对象的click事件的默认参数
	alert(this.id);//baidu
	var htmlEl = e.getTarget();//返回值是HTMLElement,得到事件触发的目标，这里也就是指<A>连接标签
	alert(htmlEl.innerText);//打印出:"百度"  （HTMLElement有innerHTML和innnerText方法。 Element没有）
	e.stopEvent();//阻止事件继续发生，也就是<A>标签不会跳转到baidu页面了
	
	//获得实际传递参数值
	alert(arguments.length);//3
	alert(arguments[2].aa);//test
	alert(arguments[2]["aa"]);//test
	
}
Ext.onReady(
	function(){
		var  baidu = Ext.get("baidu");
		baidu.on("click",todo,baidu,{aa:'test'});
	}
)

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

//父类定义
BaseClass = function(){
	//begin
	this.cry = function(){//this.不能丢
		alert("crying....");
	}
	//end
}

BaseClass.prototype.name="";
BaseClass.prototype.say = function(){
	alert("say parent");
}
BaseClass.prototype.talk = function(){
	alert("talk parent");
}
//子类定义
SubClass = function(){
	SubClass.superclass.constructor.call(this);//调用父类构造函数,也就是执行BaseClass里的begin--->end中间的代码。如果这行代码注释掉，则begin---->end中间的代码不会初始化，但是父类用prototype构造的属性和方法任然会初始化
	//js里子类实例化时是不会去自己调用父类的构造函数的
	this.walk = function(){//this.必须要加上，否则SubClass的实例对象没有办法引用到该walk方法
		alert("i'm warking");
	}
}
//继承,第3个参数{}，覆盖或者扩展父类方法，该参数也可以不要
Ext.extend(SubClass,BaseClass,{
	say:function(){
		alert("overide say");
	},
	jump:function(){
		alert("jumping");
	}
	
});
var sb = new SubClass();
sb.say();//overide say
sb.walk();//i'm warking
sb.jump();//jumping
sb.talk();//talk parent
sb.cry();//crying....

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

function add(number)
{
   alert("hello");
}

var add = new Function("number","alert('hello');");

function add()
{
	if(arguments.length == 1)
	{
	      alert(arguments[0] + 10);
	}
	if(arguments.length == 2)
	{
               alert(arguments[0] + arguments[1] + 10);
	}
			
	}
}
add(5);
add(5,1);

function a1()
{
}
function a2(number)
{
}
		
alert(a1.length);//0
alert(a2.length);//1

function test()
{
    var a = "aa";
}
alert(test());//undefined
alert(test);//function test(){ var a = "aa";}
对于函数来说，如果其不返回值，那么其返回值就为undefined

var s ;//变量s1未定义
alert(typeof s);//undefined
alert(typeof s1);//undefined
alert(s);//undefined
alert(s1);//报错

alert(undefined == null);//true

var o = new Object();
alert(o.propertyIsEnumerable("prototype"));//false,说明prototype是不可以通过for(var temp in )进行遍历出来的

var o = new Object();
for(var temp  in  o)
{
	alert(temp);	//一个都不会打印出来	
}

var o = new Object();
o.name="test";
alert(o.name);//test
delete o.name;
alert(o.name);//undefined 

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package com.test.tag;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;

@SuppressWarnings("serial")
public class HelloTag extends TagSupport {

	//doStartTag返回的都是BODY相关,doEndTag返回的都是PAGE相关
	@Override
	public int doStartTag() throws JspException {
		try {
			//通过PageContext对象的getOut()方法获得JspWriter对象输出内容
			this.pageContext.getOut().write("hello");
		} catch (IOException e) {
			e.printStackTrace();
		}
		return Tag.EVAL_BODY_INCLUDE;
	}

}

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
	<tlib-version>1.0</tlib-version>
	<jsp-version>1.2</jsp-version>
	<short-name>hello taglib test</short-name>
	<uri>/hellotag</uri>
	
	<tag>
	     <!--Tag名字 -->
		<name>hello</name>
		<!-- 该Tag对应的处理类 -->
		<tag-class>com.test.tag.HelloTag</tag-class>
		<!-- 该 Tag的body内容为空  -->
		<body-content>empty</body-content>
	</tag>
</taglib>

<%@ page language="java"  pageEncoding="UTF-8"%>
<%@ taglib uri="/hellotag" prefix="aa" %>


<html>
  <body>
    <aa:hello/>
  </body>
</html>

hello.title=tagTitle
hello.content=tagContent

package com.test.tag;

import java.io.InputStream;
import java.util.Properties;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

@SuppressWarnings("serial")
public class TagServlet extends HttpServlet {
	public void init() throws ServletException {
		System.out.println("init not param");
	}
    //init(ServletConfig config)存在，则init()方法则不会执行。如果init(ServletConfig config)不存在，则init()方法会执行
	@Override
	public void init(ServletConfig config) throws ServletException {
		try{
			System.out.println("init have param");
			Properties p = new Properties();
			//通过ServletContext读取资源文件
			ServletContext context = config.getServletContext();
			InputStream in = context.getResourceAsStream("/helloworld.properties");
			
			p.load(in);
			in.close();
			//设置属性key-value到context中
			context.setAttribute("prop", p);
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
	

}

package com.test.tag;

import java.util.Properties;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;

@SuppressWarnings("serial")
public class HelloTagByResource extends TagSupport {
	private String title;
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	//在doStartTag和doEndTag里写都可以。不要误认为："遇到标签的起始标记时，还没有解析到其属性title,所以放在doStartTag里写会报错"
	@SuppressWarnings("static-access")
	@Override
	public int doStartTag() throws JspException {
		try{
//			Properties p = (Properties)this.pageContext.getAttribute("ps",this.pageContext.APPLICATION_SCOPE);
			Properties p = (Properties)this.pageContext.getAttribute("ps",PageContext.APPLICATION_SCOPE);
			String str = p.getProperty(title);
			this.pageContext.getOut().print(str);
		}catch(Exception e){
			e.printStackTrace();
		}
		return Tag.EVAL_BODY_INCLUDE;
	}
//	@Override
//	public int doEndTag() throws JspException {
//		try{
////			Properties p = (Properties)this.pageContext.getAttribute("ps",this.pageContext.APPLICATION_SCOPE);
//			Properties p = (Properties)this.pageContext.getAttribute("ps",PageContext.APPLICATION_SCOPE);
//			String str = p.getProperty(title);
//			this.pageContext.getOut().print(str);
//		}catch(Exception e){
//			e.printStackTrace();
//		}
//		return Tag.EVAL_PAGE;
//	}

	
	
}

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
	<tlib-version>1.0</tlib-version>
	<jsp-version>1.2</jsp-version>
	<short-name>hello taglib test</short-name>
	<uri>/hellotag</uri>
	
	<tag>
	     <!--Tag名字 -->
		<name>hello</name>
		<!-- 该Tag对应的处理类 -->
		<tag-class>com.test.tag.HelloTag</tag-class>
		<!-- 该 Tag的body内容为空  -->
		<body-content>empty</body-content>
	</tag>
	
	<tag>
	     <!--Tag名字 -->
		<name>message</name>
		<!-- 该Tag对应的处理类 -->
		<tag-class>com.test.tag.HelloTagByResource</tag-class>
		<!-- 该 Tag的body内容为空  -->
		<body-content>empty</body-content>
		<!-- 属性定义 -->
		<attribute>
			<name>title</name>
			<required>true</required>
		</attribute>
	</tag>
</taglib>

<%@ page language="java"  pageEncoding="UTF-8"%>
<%@ taglib uri="/hellotag" prefix="aa" %>


<html>
  <body>
    <aa:message title="hello.title"/><br/>
    <aa:message title="hello.content"/>
  </body>
</html>

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Ext.MessageBox.alert("ok");


   Ext.Msg.show({
	   title:'Save Changes?',
	   msg: 'You are closing a tab that has unsaved changes. Would you like to save your changes?',
	   //值只能为MessageBox里Public Properties中的Button config
	   buttons: Ext.Msg.YESNOCANCEL,
	   //fn为回调
//	   fn: processResult,
	   animEl: 'elId',
	   //值只能为：值只能为MessageBox里Public Properties中的The CSS class
	   icon: Ext.MessageBox.WARNING
	});

  	  var viewport = new Ext.Viewport({
  	     id:'desk',
  	     layout:'border',
  	     items:[{region:'north',height:50},{region:'west',width:200},{region:'center'}]
  	    }	
  	  		
  	  );

  	var panel = new Ext.Panel({
//  	        renderTo:'hello'可以替换掉panel.render("hello");
  	    id:'hello',
  	    title:'panlehell',
  	    width:200,
  	    height:200
  		
  	});
  	panel.render("hello");

 var tabPanel = new Ext.TabPanel({
    	    renderTo:'hello',
    	    activeTab: 0,
    		width:200,
    		height:200,
    		items:[
    		{title:'hello1',html:'hello1 content!'},//默认是Panel
    		new Ext.Panel({title:'hello2',html:'hello2 content'}),
    		new Ext.tree.TreePanel(  {title:'树面板',loader:new Ext.tree.TreeLoader(),root:new Ext.tree.AsyncTreeNode( {text:'根节点',children:[ { leaf:true,text:'叶子1' }, { leaf:true,text:'叶子2' } ]  } )  }  ),
    		  {xtype:'treepanel',title:'树面板',loader:new Ext.tree.TreeLoader(),root:new Ext.tree.AsyncTreeNode( {text:'根节点',children:[ { leaf:true,text:'叶子1' }, { leaf:true,text:'叶子2' } ]  } )  }  
    		]
    	}
    );

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package com.jetty;

import org.mortbay.http.SocketListener;
import org.mortbay.jetty.Server;

public class JettyTest {


	public static void main(String[] args) throws Exception {
		//定义一个Server对象
		Server server = new Server();
		
		SocketListener socket = new SocketListener() ;
		socket.setPort(9999);
		//设置服务端口号
		server.addListener(socket);
		//设置Context
		server.addWebApplication("/test1", "D:\\java\\jetty-5.1.12\\webapps\\template");
		//启动
		server.start();
		
	}

}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

 <servlet>
    <servlet-name>ServletTestRunner</servlet-name>
    <servlet-class>org.apache.cactus.server.runner.ServletTestRunner</servlet-class>
    </servlet>
  <servlet-mapping>
    <servlet-name>ServletTestRunner</servlet-name>
    <url-pattern>/ServletTestRunner</url-pattern>
  </servlet-mapping>
  
  
  <servlet>
    <servlet-name>ServletTestRedirector</servlet-name>
    <servlet-class>org.apache.cactus.server.ServletTestRedirector</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ServletTestRedirector</servlet-name>
    <!--这个url-pattern的值必须为/ServletRedirector,不能换成其它-->
    <url-pattern>/ServletRedirector</url-pattern>
  </servlet-mapping>

public class FirstServlet extends HttpServlet {
       public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		if(isLogin(request)){
			System.out.println("success");
		}else{
			System.out.println("fail");
			request.getSession().setAttribute("user", "users");
		}
		
	}

         public boolean isLogin(HttpServletRequest request){
		if(null == request.getSession().getAttribute("user")){
			return false;
		}else{
			return true;
		}
	}

}

import junit.framework.Assert;

import org.apache.cactus.ServletTestCase;

public class FirstServletTest extends ServletTestCase {

	public void testIsLogin(){
		FirstServlet test = new FirstServlet();
		boolean result = test.isLogin(request);
		Assert.assertEquals(false, result);
	}

}

import junit.framework.Test;
import junit.framework.TestSuite;

public class TestAll {
	
	public static Test suite(){
		TestSuite suite = new TestSuite("test all");
		suite.addTestSuite(FirstServletTest.class);
		return suite;
	}

}

<servlet>
    <servlet-name>ServletTestRunner</servlet-name>
    <servlet-class>org.apache.cactus.server.runner.ServletTestRunner</servlet-class>
    <init-param>
    	<param-name>xsl-stylesheet</param-name>
    	<param-value>cactus-report.xsl</param-value>
    </init-param>
    
  </servlet>

package com.test;

import junit.framework.Assert;

import org.apache.cactus.ServletTestCase;
import org.apache.cactus.WebRequest;
import org.apache.cactus.WebResponse;

public class FirstServletTest2 extends ServletTestCase {

	/**
	 *每个测试方法前都会去执行
	 */
	public void begin(WebRequest request){
		System.setProperty("cactus.contextURL", "http://localhost:8080/cactusTest");
		System.out.println("begin");
	}
	/**
	 *只是在isLogin测试方法前才会去执行
	 */
	public void beginIsLogin(WebRequest request){
		System.out.println("begin isLogin");
	}
	
	public void setUp(){
		System.out.println("setUp");
	}
	public void testIsLogin(){
		FirstServlet test = new FirstServlet();
		boolean result = test.isLogin(request);
		Assert.assertEquals(false, result);
	}
	public void tearDown(){
		System.out.println("tearDown");
	}
	/**
	 *每个测试方法后都会去执行
	 */
	public void end(WebResponse response){
		System.out.println("end");
	}
	
	/**
	 *只是在isLogin测试方法后才会去执行
	 */
	public void endIsLogin(WebResponse response){
		System.out.println("end isLogin");
	}

}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

log4j.rootLogger=info,Console,R 

log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
#log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
log4j.appender.Console.layout.ConversionPattern=%d{yy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n 

log4j.appender.R=org.apache.log4j.DailyRollingFileAppender
log4j.appender.R.File=${catalina.home}/logs/tomcat.log 
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%d{yyyy.MM.dd HH:mm:ss} %5p %c{1}(%L):? %m%n 

log4j.logger.org.apache=info, R
log4j.logger.org.apache.catalina.core.ContainerBase.[Catalina].[localhost]=DEBUG, R 
log4j.logger.org.apache.catalina.core=info, R
log4j.logger.org.apache.catalina.session=info, R 

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package com.pattern.decorator;
/**
 * 抽象构件角色
 */
public interface Component {

	public void doSomething();
}

package com.pattern.decorator;
/**
 * 具体构件角色
 */
public class ConcreteComponent implements Component {

	public void doSomething() {
		System.out.println("功能A");
	}

}

package com.pattern.decorator;
/**
 * 装饰角色
 */
public class Decorator implements Component {
    //拥有一个抽象构件对象
	private Component component;
	public Decorator(Component component){
		this.component = component;
	}
	public void doSomething() {
		component.doSomething();
	}

}

package com.pattern.decorator;
/**
 * 具体装饰角色一
 */
public class ConcreteDecorator1 extends Decorator {

	public ConcreteDecorator1(Component component){
		super(component);
	}
	
	public void doSomething(){
		super.doSomething();
		this.doAnotherthing();
		
	}
	private void doAnotherthing(){
		System.out.println("功能B");
	}
}

package com.pattern.decorator;
/**
 * 具体装饰角色二
 */
public class ConcreteDecorator2 extends Decorator {

	public ConcreteDecorator2(Component component){
		super(component);
	}
	
	public void doSomething(){
		super.doSomething();
		this.doAnotherthing();
		
	}
	private void doAnotherthing(){
		System.out.println("功能C");
	}
}

package com.pattern.decorator;
/**
 * 客户端
 */
public class Client {
	
	public static void main(String[] args){
   //扩充了component 对象的功能。
		Component component = new ConcreteDecorator2(new ConcreteDecorator1(new ConcreteComponent()));
		component.doSomething();
	}
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package com.pattern.adapter.classadapter;
/**
 * 客户端要使用的目标类
 *
 */
public interface Target {
	
	public void method1();

}

package com.pattern.adapter.classadapter;

public class Adaptee {
	
	public void method2(){
		System.out.println("执行...");
	}

}

package com.pattern.adapter.classadapter;
//继承Adaptee类
public class Adapter extends Adaptee implements Target {

	//包装类
	public void method1() {
		this.method2();
	}

}

package com.pattern.adapter.classadapter;
//适配器模式也叫包装模式
public class Client {
	//类适配器模式
	public static void main(String[] args){
		Target target = new Adapter();
		target.method1();
	}

}

package com.pattern.adapter.objectadapter;
/**
 * 客户端要使用的目标类
 *
 */
public interface Target {
	public void method1();
}

package com.pattern.adapter.objectadapter;

public class Adaptee {
	
	public void method2(){
		System.out.println("执行...");
	}

}

package com.pattern.adapter.objectadapter;

//不继承Adaptee类
public class Adapter implements Target {

	private Adaptee adaptee ;
	public Adapter(Adaptee adaptee){
		this.adaptee = adaptee;
	}
	
	public void method1() {
		adaptee.method2();
	}

}

package com.pattern.adapter.objectadapter;
//适配器模式也叫包装模式
public class Client {
	//对象适配器模式
	public static void main(String[] args){
		Target target = new Adapter(new Adaptee());
		target.method1();
	}

}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

<script>
var intIndex=0;arrList = new Array();

arrList = "${result}".replace('[','').replace(']','').split(',');

</script>

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package com.pattern.composite;
/**
 * 组件抽象角色
 *
 */
public interface Component {
	
	public void run();

}

package com.pattern.composite;
/**
 * 叶子角色
 *
 */
public class Leaf implements Component{
	
	public void run(){
		System.out.println(" run invoked...");
	}

}

package com.pattern.composite;

import java.util.ArrayList;
import java.util.List;
/**
 * 组合角色
 * 实现组件角色接口，并且添加，删除的也是组件角色
 * 
 * Composite本来可以再包含Leaf和Composite的。而 Leaf和Composite 又都属于 Component，所以增加，删除 的是Component
 * 
 * 组合模式主要分为2种
 * 
 * 1 透明式

	添加Component对象的操作定义在Component角色中，这样的话不仅Composite需要实现这些方法，Leaf也需要实现这些方法，
	而这些方法对于Leaf来说没有任何意义，不过将系统实现统一起来了，因此对用户来说透明（用户无需区分Composite还是Leaf）
	，因为这些角色中都具备这些方法。
	
   2 安全式

	添加Component对象的操作定义在Composite角色中，这样的话Leaf就无需实现这些方法（因为Leaf本身根本不需要实现这些方法）
 *
 */
public class Composite  implements Component{
	
	List<Component> list = new ArrayList<Component>();
	
	//添加
	public void addComponent(Component component){
		list.add(component);
	}
	//删除
	public void removeComponent(Component component){
		list.remove(component);
	}
	
	//get
	public List<Component> getAll(){
		return list;
	}
	
	public void run(){
		for(Component component : list){
			component.run();
		}
	}

}

package com.pattern.composite;

public class Client {

	public static void main(String[] args){
		Leaf leaf1 = new Leaf();
		Leaf leaf2 = new Leaf();
		Leaf leaf3 = new Leaf();
		
		Composite composite = new Composite();
		
		composite.addComponent(leaf1);
		composite.addComponent(leaf2);
		
		Composite composite1 = new Composite();
		composite1.addComponent(composite);
		composite1.addComponent(leaf3);
		
		composite1.run();
		
	}
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package com.pattern.command;
/**
 *接受者（相当于厨师）
 */
public class Receiver {
	
	public void doReceiverAction(){
		System.out.println("接受者执行完毕");
	}

}

package com.pattern.command;
/**
 *命令角色
 */
public interface Command {
	
	public void execute();

}

package com.pattern.command;

/**
 * 具体命令角色,调用接受者执行具体命令。自己不能执行具体命令，所以需要创建一个接受者对象
 */
public class CommandImpl implements Command{

	private Receiver receiver;
	public CommandImpl(Receiver receiver){
		this.receiver = receiver;
	}
	public void execute(){
		receiver.doReceiverAction();
	}
}

package com.pattern.command;
/**
 * 请求者角色，需要发出一个命令，所以需要创建一个命令角色的对象.(相当于顾客)
 */
public class ReqRole {

	private Command command;
	public ReqRole(Command command){
		this.command = command;
	}
	public  void  doAction(){
		command.execute();
	}
	
}

package com.pattern.command;
/**
 *客户角色
 */
public class Test {
	
	public static void main(String[] args){
		
		Receiver receiver = new Receiver();//接受者。不和任何对象关联
		
		Command command = new CommandImpl(receiver);//构建一个命令角色。因为自己不执行任何命令，真正执行命令的是接受者，所以需要传递一个接受者对象
		
		ReqRole reqRole = new ReqRole(command);//请求角色。因为需要请求一个命令，所以需要接受一个命令角色对象
	
		reqRole.doAction();
	}
	

}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

package org.test.db;

import java.sql.Connection;
import java.sql.DriverManager;

public class Conn {
	
	private static  String url = "jdbc:sqlserver://localhost:1433;DatabaseName=frame";
	private static  String username = "sa";
	private static  String password = "123456";
	private static  String driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
	
	public static Connection getConnection(){
		Connection conn = null;
		try{
			Class.forName(driver);
			conn = DriverManager.getConnection(url,username,password);
		}catch(Exception e){
			e.printStackTrace();
		}
		return conn;
	}

}

package org.test.db;

import java.sql.Connection;

import org.junit.Assert;
import org.junit.Test;

public class ConnTest {

	@Test
	public void testGetConnection() {
		Connection conn = Conn.getConnection();
		Assert.assertNotNull(conn);
	}

}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public int add(int a,int b){
		return a+b;
	}

package org.test;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
/**
 * 参数化测试的类必须有Parameterized测试运行器修饰
 *
 */
@RunWith(Parameterized.class)
public class AddTest3 {

	private int input1;
	private int input2;
	private int expected;
	
	/**
	 * 准备数据。数据的准备需要在一个方法中进行，该方法需要满足一定的要求：

		 1）该方法必须由Parameters注解修饰
		 2）该方法必须为public static的
		 3）该方法必须返回Collection类型
		 4）该方法的名字不做要求
		 5）该方法没有参数
	 * @return
	 */
	@Parameters
	@SuppressWarnings("unchecked")
	public static Collection prepareData(){
		Object [][] object = {{-1,-2,-3},{0,2,2},{-1,1,0},{1,2,3}};
		return Arrays.asList(object);
	}
	
	public AddTest3(int input1,int input2,int expected){
		this.input1 = input1;
		this.input2 = input2;
		this.expected = expected;
	}
	@Test
	public void testAdd(){
		Add add = new Add();
		int result = add.add(input1, input2);
		Assert.assertEquals(expected,result);
	}
	
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package org.test;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
/**
 * 不需要再继承TestCase
 *
 */
public class AddTest2 {
	public AddTest2(){
		System.out.println("constructor invoked!");
	}
	private static Add add ;
	
	/**
	 * junit4里新增的特性，必须是static的，全局只执行一次，在所以测试方法前执行,并且是在该测试类的构造函数执行前执行。仅执行一次
	 */
	@BeforeClass
	public static void globalInit(){
		add = new Add();
		System.out.println("global init");
	}
	/**
	 * 相当于junit3.8里的setUp()，每个测试方法执行前都会执行一次
	 */
	@Before
	public void init(){
		System.out.println("init");
	}
	/**
	 * 相当于junit3.8里的tearDown
	 */
	public void destroy(){
		System.out.println("destroy");
	}
	/**
	 * junit4里方法名字可以随便起，但是必须满足
	 * 1）public
	 * 2) void
	 * 3) 方法没有参数
	 */
	@Test
	public void myAdd(){
		int result = add.add(3, 5);
		Assert.assertEquals(8, result);
	}

}

package org.test;

import org.junit.Test;

public class DivideTest2 {
	
	private Divide divide ;
	public void init(){
		divide = new Divide();
	}
	/**
	 * 加了expected参数意思是，该方法必须抛出该异常，否则测试失败
	 * @throws Exception
	 */
	@Test(expected = Exception.class)
	public void myDivide() throws Exception{
		int result = divide.divide(10, 0);
	}

}

package org.test;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
/**
 * RunWith注解的参数value值必须是一个测试运行器，也就是必须是org.junit.runner.Runner类或其子类。org.junit.runners.Suite是Runner的子类
 *
 */
@RunWith(Suite.class)
@Suite.SuiteClasses({AddTest2.class,DivideTest2.class})
public class TestAll1 {

}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package org.test;
package org.test;

import junit.swingui.TestRunner;

public class Add {
	
	public int add(int a,int b){
		return a+b;
	}
	
	public static void main(String[] args){
		TestRunner runner = new TestRunner();
		runner.run(AddTest.class);
	}

}

package org.test;

import junit.framework.Assert;
import junit.framework.TestCase;

public class AddTest extends TestCase {
	
	private Add add = null;
	 
	@Override
	protected void setUp() throws Exception {
		add = new Add();
	}

	/**满足条件
	 * 1)必须是public
	 * 2)必须是void
	 * 3)必须以test开头
	 * 4)必须无参数
	 */
	public void testAdd(){
		int result = add.add(3, 5);
		Assert.assertEquals(8, result);
	}

}

package org.test;

public class Divide {
	
	public int divide(int a,int b) throws Exception{
		if(0 == b){
			throw new Exception("除数不能为0");
		}
		return a/b;
	}

}

package org.test;

import junit.framework.Assert;
import junit.framework.TestCase;

public class DivideTest  extends TestCase {
	
	private Divide divide = null;
	 
	@Override
	protected void setUp() throws Exception {
		divide = new Divide();
	}

	/**满足条件
	 * 1)必须是public
	 * 2)必须是void
	 * 3)必须以test开头
	 * 4)必须无参数
	 */
	public void testDivide(){
		int result = 0;
		try {
			result = divide.divide(10, 2);
		} catch (Exception e) {
			e.printStackTrace();
		}
		Assert.assertEquals(5, result);
	}
	
	public void testDivide0(){
		
		Throwable tx = null;
		try {
			int result = divide.divide(10, 0);
			Assert.fail();//"出错了"的意思
		} catch (Exception e) {
			tx = e;
		}
		
		Assert.assertNotNull(tx);
		Assert.assertEquals(Exception.class, tx.getClass());
		Assert.assertEquals("除数不能为0", tx.getMessage());
		
	}
}

package org.test;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

public class TestAll extends TestCase {
	
	/**
	 * 方法必须这样写
	 * @return
	 */
	public static  Test suite(){
		TestSuite suite = new TestSuite();
		
		suite.addTestSuite(DivideTest.class);
		suite.addTestSuite(AddTest.class);
		
		return suite;
	}

}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

[mysqld]
log-bin=mysql-testsyn-bin --主库二进制日志文件名的前缀
binlog-do-db=testsyn      --要同步的数据库
server-id = 1             --serverid和辅库不同即可

grant replication slave on *.* to "testsyn"@"192.168.40.%" identified by 'testsyn' with grant option;

show master status;

server-id = 2
master-host = 192.168.40.4
master-user = testsyn 
master-password = testsyn
master-port = 3306
master-connect-retry = 5  --重试间隔时间
replicate-do-db = testsyn    --同步db
#replicate-wild-do-table = user%.%
#replicate-do-db = itemcontent
#replicate-do-db = srcstore

 show slave status;

mysqldump --opt --master-data -uspider -pcrawler testsyn > /home/mahaibo/dump-testsyn &

stop slave

mysql -uspider -pcrawler testsyn < /home/mahaibo/dump-testsyn 


start slave;

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

<servlet>
    <servlet-name>dwr-invoker</servlet-name>
    <servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>
    <init-param>
      <param-name>debug</param-name>
      <param-value>true</param-value>
      <!--开发阶段把debug设置为true,可以http://localhost:8080/dwrtest/dwr进行详细查看-->
    </init-param>
    <init-param>
      <param-name>activeReverseAjaxEnabled</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>initApplicationScopeCreatorsAtStartup</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>maxWaitAfterWrite</param-name>
      <param-value>100</param-value>
    </init-param>
    <init-param>   
            <param-name>crossDomainSessionSecurity</param-name>   
            <param-value>false</param-value>   
    </init-param>

    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
	    <servlet-name>dwr-invoker</servlet-name>
	    <url-pattern>/dwr/*</url-pattern>
  </servlet-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE dwr PUBLIC "-//GetAhead Limited//DTD Direct Web Remoting 2.0//EN" "http://getahead.org/dwr/dwr20.dtd">

<dwr>

  <allow>
    <create creator="new" javascript="service">
      <param name="class" value="helloworld.Service"/>
      <include method="sayHello"/>
    </create>
  </allow>

</dwr>

package helloworld;

public class Service {

	public String sayHello(String yourname){
		return "hello :" + yourname;
	}
}

<%@ page language="java" pageEncoding="UTF-8"%> 
<html> 
<head>
	 <title>
		 My JSP 'first_dwr.jsp' starting page
	 </title> 
	 <script type='text/javascript' src='dwr/util.js'></script> 
	 <script type='text/javascript' src='dwr/engine.js'></script>
	 <script type='text/javascript' src='dwr/interface/service.js'> </script> 
	 <script type="text/javascript"> 
	 	
	 	function show(){
	 		var str = $("text").value;
	 		service.sayHello(str,callBack);//not callBack();
	 	}
	 	function callBack(data)//not (var data)
	 	{
	 		dwr.util.setValue("showName",data,{escapeHtml:true});
	 	}
	 </script> 
  
 </head>
 
 <body>
 
  <input type="text" id="text" ><input type="button" onclick="show()" value="submit">
  <div id="showName"></div>
 
 </body> 
 
 </html>

                function show()
                {
	 		var str = $("text").value;
	 		service.sayHello(str,callBack);//not callBack();
	 	}

	 	function callBack(data)//not (var data)
	 	{
	 		dwr.util.setValue("showName",data,{escapeHtml:true});
	 	}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师