ITTechnology

JAVA开发全集

soap消息的分析和消息的创建和传递和处理

@WebService
public interface IMyService {
@WebResult(name="addResult")
public int add(@WebParam(name="a")int a,@WebParam(name="b")int b);

@WebResult(name="user")
public User addUser(@WebParam(name="user")User user);

@WebResult(name="user")
public User login(@WebParam(name="username")String username,
@WebParam(name="password")String password)throws UserException;

@WebResult(name="user")
public List list(@WebParam(header=true,name="authInfo")String authInfo);
}

@XmlRootElement
public class User {
private int id;
private String username;
private String nickname;
private String password;
public int getId() {
  return id;
}
public void setId(int id) {
  this.id = id;
}
public String getUsername() {
  return username;
}
public void setUsername(String username) {
  this.username = username;
}
public String getNickname() {
  return nickname;
}
public void setNickname(String nickname) {
  this.nickname = nickname;
}
public String getPassword() {
  return password;
}
public void setPassword(String password) {
  this.password = password;
}
public User(int id, String username, String nickname, String password) {
  super();
  this.id = id;
  this.username = username;
  this.nickname = nickname;
  this.password = password;
}
public User() {
  super();
}

}

public class MyServer {

public static void main(String[] args) {
Endpoint.publish("http://localhost:8989/ms", new MyServiceImpl());
}

}

@WebService(endpointInterface="org.soap.service.IMyService")
@HandlerChain(file="handler-chain.xml")
public class MyServiceImpl implements IMyService {
private static List users = new ArrayList();

public MyServiceImpl() {
users.add(new User(1,"admin","","111111"));
}

@Override
public int add(int a, int b) {
System.out.println("a+b="+(a+b));
return a+b;
}

@Override
public User addUser(User user) {
users.add(user);
return user;
}

@Override
public User login(String username, String password) throws UserException{
  for(User user:users) {
   if(username.equals(user.getUsername())&&password.equals(user.getPassword()))
    return user;
  }
  throw new UserException("");
}

@Override
public List list(String authInfo) {
System.out.println(authInfo);
return users;
}

}

public class TestSoap {

private static String ns = "http://service.soap.org/";
private static String wsdlUrl = "http://localhost:8989/ms?wsdl";

        public static void main(String[] args){
            TestSoap.test03();
        }

@Test
public static void test01() {
 try {
 //1��创建消息工厂��
 MessageFactory factory = MessageFactory.newInstance();
 //2��根据消息工厂创建SoapMessage
 SOAPMessage message = factory.createMessage();
 //3��创建SOAPPart
 SOAPPart part = message.getSOAPPart();
 //4��获取SOAPENvelope
 SOAPEnvelope envelope = part.getEnvelope();
 //5��可以通过SoapEnvelope有效的获取相应的Body和Header等信息
 SOAPBody body = envelope.getBody();
 //6��根据Qname创建相应的节点(QName就是一个带有命名空间的节点)��ռ��)
 QName qname = new QName("http://java.zttc.edu.cn/webservice",
 "add","ns");//
 //�如果使用以下方式进行设置，会见<>转换为<和>
 //body.addBodyElement(qname).setValue("12");
 SOAPBodyElement ele = body.addBodyElement(qname);
 ele.addChildElement("a").setValue("22");
 ele.addChildElement("b").setValue("33");
 //打印消息信息
 message.writeTo(System.out);
 } catch (SOAPException e) {
 e.printStackTrace();
 } catch (IOException e) {
 e.printStackTrace();
 }
}

@Test//基于soap的消息传递
public static void test02() {
 try {
 //1��创建服务(Service)
 URL url = new URL(wsdlUrl);
 QName sname = new QName(ns,"MyServiceImplService");
 Service service = Service.create(url,sname);

 //2��创建Dispatch
 Dispatch dispatch = service.createDispatch(new QName(ns,"MyServiceImplPort"),
 SOAPMessage.class, Service.Mode.MESSAGE);

 //3��创建SOAPMessage
 SOAPMessage msg = MessageFactory.newInstance().createMessage();
 SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();
 SOAPBody body = envelope.getBody();

 //4��创建QName来指定消息中传递数据��
 QName ename = new QName(ns,"add","nn");//
 SOAPBodyElement ele = body.addBodyElement(ename);
 ele.addChildElement("a").setValue("22");
 ele.addChildElement("b").setValue("33");
 msg.writeTo(System.out);
 System.out.println("\n invoking.....");


 //5�通过Dispatch传递消息,会返回响应消息
 SOAPMessage response = dispatch.invoke(msg);
 response.writeTo(System.out);
 System.out.println("\n----------------------------------------");

 //��将响应的消息转换为dom对象��
 Document doc = response.getSOAPPart().getEnvelope().getBody().extractContentAsDocument();
 String str = doc.getElementsByTagName("addResult").item(0).getTextContent();
 System.out.println(str);
 } catch (SOAPException e) {
 e.printStackTrace();
 } catch (IOException e) {
 e.printStackTrace();
 }
}

@Test
public static void test03() {
 try {
 //1��创建服务(Service)
 URL url = new URL(wsdlUrl);
 QName sname = new QName(ns,"MyServiceImplService");
 Service service = Service.create(url,sname);

 //2��创建Dispatch(通过源数据的方式传递)
 Dispatch dispatch = service.createDispatch(new QName(ns,"MyServiceImplPort"),
 Source.class, Service.Mode.PAYLOAD);
 //3��根据用户对象创建相应的xml
 User user = new User(3,"zs","张三","11111");
 //编排user对象
 JAXBContext ctx = JAXBContext.newInstance(User.class);
 Marshaller mar = ctx.createMarshaller();
 //不会再创建xml的头信息
 mar.setProperty(Marshaller.JAXB_FRAGMENT, true);
 StringWriter writer= new StringWriter();
 mar.marshal(user, writer);
 System.out.println("writer====="+writer);
 //4、封装相应的part addUser
 String payload = ""+writer.toString()+"";
 System.out.println("payload====="+payload);
 StreamSource rs = new StreamSource(new StringReader(payload));

 //5�通过dispatch传递payload
 Source response = (Source)dispatch.invoke(rs);

 //6�将Source转化为DOM进行操作，使用Transform对象转换
 Transformer tran = TransformerFactory.newInstance().newTransformer();
 DOMResult result = new DOMResult();
 tran.transform(response, result);

 //7��处理相应信息(通过xpath处理)
 XPath xpath = XPathFactory.newInstance().newXPath();
 NodeList nl = (NodeList)xpath.evaluate("//user", result.getNode(),XPathConstants.NODESET);
 User ru = (User)ctx.createUnmarshaller().unmarshal(nl.item(0));
 System.out.println(ru.getNickname());
 } catch (IOException e) {
 e.printStackTrace();
 } catch (JAXBException e) {
 e.printStackTrace();
 } catch (TransformerConfigurationException e) {
 e.printStackTrace();
 } catch (TransformerFactoryConfigurationError e) {
 e.printStackTrace();
 } catch (TransformerException e) {
 e.printStackTrace();
 } catch (XPathExpressionException e) {
 e.printStackTrace();
 }
}

schema的笔记

schema文件：

  targetNamespace=" http://www.example.org/01"
  xmlns:tns=" http://www.example.org/01"
  elementFormDefault="qualified">









xml文件1:

   xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation=" http://www.example.org/01">
1
zhangsan
1989-12-22

xml文件2:

   xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="01.xsd">
11
lisi
1988-11-11

schema文件2：

xmlns:tns="http://www.example.org/02" elementFormDefault="qualified">

xml文件：

   xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="02.xsd">

  Java in action
  Java is good
  Bruce

  SOA in action
  soa is difficult

   Jike


schema文件3：

  targetNamespace=" http://www.example.org/04"
  xmlns:tns=" http://www.example.org/04"
  elementFormDefault="qualified">

























xml文件：

   xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation=" http://www.example.org/04" sex="男">
搜索
149
[email protected]

schema文件4：

dtd讲解

classroom.dtd文件：

classroom.xml文件：

10计算机应用技术
2010


   1
   zhangsan
   12


   2
   lisi
   122

使用soap协议用java语言建立服务发送xml文件，接收xml文件

private static String ns = " http://service.soap.org/";
private static String wsdlUrl = " http://localhost:8989/ms?wsdl";public static void test02() {
  try {
   //1��创建服务(Service)
   URL url = new URL(wsdlUrl);
   QName sname = new QName(ns,"MyServiceImplService");
   Service service = Service.create(url,sname);

   //2��创建Dispatch
   Dispatch dispatch = service.createDispatch(new QName(ns,"MyServiceImplPort"),
      SOAPMessage.class, Service.Mode.MESSAGE);

   //3��创建SOAPMessage
   SOAPMessage msg = MessageFactory.newInstance().createMessage();
   SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();
   SOAPBody body = envelope.getBody();

   //4��创建QName来指定消息中传递数据��
   QName ename = new QName(ns,"add","nn");//
   SOAPBodyElement ele = body.addBodyElement(ename);
   ele.addChildElement("a").setValue("22");
   ele.addChildElement("b").setValue("33");
   msg.writeTo(System.out);
   System.out.println("\n invoking.....");


   //5�通过Dispatch传递消息,会返回响应消息
   SOAPMessage response = dispatch.invoke(msg);
   response.writeTo(System.out);
   System.out.println("\n----------------------------------------");

   //��将响应的消息转换为dom对象��
   Document doc = response.getSOAPPart().getEnvelope().getBody().extractContentAsDocument();
   String str = doc.getElementsByTagName("addResult").item(0).getTextContent();
   System.out.println(str);
  } catch (SOAPException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
}

XPath解析，写入，修改xml文件

public static void test06() {
  InputStream is = null;
  try {
   is = TestStax.class.getClassLoader().getResourceAsStream("books.xml");
   //创建文档处理对象
   DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
   //通过DocumentBuilder创建doc的文档对象
   Document doc = db.parse(is);
   //创建XPath
   XPath xpath = XPathFactory.newInstance().newXPath();
   //第一个参数就是xpath,第二参数就是文档
   NodeList list = (NodeList)xpath.evaluate("//book[@category='WEB']", doc,XPathConstants.NODESET);
   for(int i=0;i     //遍历输出相应的结果
    Element e = (Element)list.item(i);
    System.out.println(e.getElementsByTagName("title").item(0).getTextContent());
   }
  } catch (ParserConfigurationException e) {
   e.printStackTrace();
  } catch (SAXException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  } catch (XPathExpressionException e) {
   e.printStackTrace();
  } finally {
   try {
    if(is!=null) is.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
}

@Test
public static void test07() {
  try {
   XMLStreamWriter xsw = XMLOutputFactory.newInstance().createXMLStreamWriter(System.out);
   xsw.writeStartDocument("UTF-8","1.0");
   xsw.writeEndDocument();
   String ns = " http://11:dd";
   xsw.writeStartElement("nsadfsadf","person",ns);
   xsw.writeStartElement(ns,"id");
   xsw.writeCharacters("1");
   xsw.writeEndElement();
   xsw.writeEndElement();
   xsw.flush();
   xsw.close();
  } catch (XMLStreamException e) {
   e.printStackTrace();
  } catch (FactoryConfigurationError e) {
   e.printStackTrace();
  }
}

@Test
public static void test08() {
  InputStream is = null;
  try {
   is = TestStax.class.getClassLoader().getResourceAsStream("books.xml");
   //创建文档处理对象
   DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
   //通过DocumentBuilder创建doc的文档对象
   Document doc = db.parse(is);
   //创建XPath
   XPath xpath = XPathFactory.newInstance().newXPath();
   Transformer tran = TransformerFactory.newInstance().newTransformer();
   tran.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
   tran.setOutputProperty(OutputKeys.INDENT, "yes");
   //第一个参数就是xpath,第二参数就是文档
   NodeList list = (NodeList)xpath.evaluate("//book[title='Learning XML']", doc,XPathConstants.NODESET);
   //获取price节点
   Element be = (Element)list.item(0);
   Element e = (Element)(be.getElementsByTagName("price").item(0));
   e.setTextContent("333.9");
   Result result = new StreamResult(System.out);
   //通过tranformer修改节点
   tran.transform(new DOMSource(doc), result);
  } catch (ParserConfigurationException e) {
   e.printStackTrace();
  } catch (SAXException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  } catch (XPathExpressionException e) {
   e.printStackTrace();
  } catch (TransformerConfigurationException e) {
   e.printStackTrace();
  } catch (TransformerFactoryConfigurationError e) {
   e.printStackTrace();
  } catch (TransformerException e) {
   e.printStackTrace();
  } finally {
   try {
    if(is!=null) is.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
}

XMLEventReader的基于Filter的过滤方式解析xml文件

public static void test05() {
  XMLInputFactory factory = XMLInputFactory.newInstance();
  InputStream is = null;
  try {
   is = TestStax.class.getClassLoader().getResourceAsStream("books.xml");
   //基于Filter的过滤方式，可以有效的过滤掉不用进行操作的节点，效率会高一些
   XMLEventReader reader = factory.createFilteredReader(factory.createXMLEventReader(is),
     new EventFilter() {
      @Override
      public boolean accept(XMLEvent event) {
       //返回true表示会显示，返回false表示不显示
       if(event.isStartElement()) {
        String name = event.asStartElement().getName().toString();
        if(name.equals("title")||name.equals("price"))
         return true;
       }
       return false;
      }
     });
   int num = 0;
   while(reader.hasNext()) {
    //通过XMLEvent来获取是否是某种节点类型
    XMLEvent event = reader.nextEvent();
    if(event.isStartElement()) {
     //通过event.asxxx转换节点
     String name = event.asStartElement().getName().toString();
     if(name.equals("title")) {
      System.out.print(reader.getElementText()+":");
     }
     if(name.equals("price")) {
      System.out.print(reader.getElementText()+"\n");
     }
    }
    num++;
   }
   System.out.println(num);
  } catch (XMLStreamException e) {
   e.printStackTrace();
  } finally {
   try {
    if(is!=null) is.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
}

XMLEventReader迭代解析xml文件

public static void test04() {
  XMLInputFactory factory = XMLInputFactory.newInstance();
  InputStream is = null;
  try {
   is = TestStax.class.getClassLoader().getResourceAsStream("books.xml");
   //基于迭代模型的操作方式
   XMLEventReader reader = factory.createXMLEventReader(is);
   int num = 0;
   while(reader.hasNext()) {
    //通过XMLEvent来获取是否是某种节点类型
    XMLEvent event = reader.nextEvent();
    if(event.isStartElement()) {
     //通过event.asxxx转换节点
     String name = event.asStartElement().getName().toString();
     if(name.equals("title")) {
      System.out.print(reader.getElementText()+":");
     }
     if(name.equals("price")) {
      System.out.print(reader.getElementText()+"\n");
     }
    }
    num++;
   }
   System.out.println(num);
  } catch (XMLStreamException e) {
   e.printStackTrace();
  } finally {
   try {
    if(is!=null) is.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
}

XMLStreamReader光标解析xml文件

public static void test01() {
  XMLInputFactory factory = XMLInputFactory.newInstance();
  InputStream is = null;
  try {
   is = TestStax.class.getClassLoader().getResourceAsStream("books.xml");
   XMLStreamReader reader = factory.createXMLStreamReader(is);
   while(reader.hasNext()) {
                        //    System.out.println("------------------------------------------------");
    int type = reader.next();
                                 System.out.println("type---"+type);
    //判断节点类型是否是开始或者结束或者文本节点,之后根据情况及进行处理
    if(type==XMLStreamConstants.START_ELEMENT) {//==1，指示事件是一个开始元素
     System.out.println(reader.getName());
                                        String name = reader.getName().toString();
                                        if("book".equals(name)){
                                            System.out.println(reader.getAttributeName(0)+":"+reader.getAttributeValue(0));
                                        }else if("title".equals(name)){
                                            System.out.println(reader.getAttributeName(0)+":"+reader.getAttributeValue(0));
                                        }

                                        // System.out.println("==1，指示事件是一个开始元素");
    } else if(type==XMLStreamConstants.CHARACTERS) {//==4指示事件是一些字符
     System.out.println(reader.getText().trim());
                                    // System.out.println("==4指示事件是一些字符");
    } else if(type==XMLStreamConstants.END_ELEMENT) {//==2,指示事件是一个结束元素
     System.out.println("/"+reader.getName());
                                     // System.out.println("==2,指示事件是一个结束元素");
    }
                                //else if(type==XMLStreamConstants.ATTRIBUTE){
//                                   int count = reader.getAttributeCount();
//                                   System.out.println("count========"+count);
//                                 if(count>0){
//                                     int i=0;
//                                     int[] arr = new int[count];
//                                     while(i //                                         arr[i]=i;
//                                         i++;
//                                     }
//                                     for(int a : arr){
//                                         System.out.println(reader.getAttributeValue(a));
//                                     }
//                                 }
//                                }
   }
  } catch (XMLStreamException e) {
   e.printStackTrace();
  } finally {
   try {
    if(is!=null) is.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
}

使用jaxb完成对象和xml的转换

学生类

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Student {
private int id;
private String name;
private int age;
private Classroom classroom;
public int getId() {
  return id;
}
public void setId(int id) {
  this.id = id;
}
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}
public int getAge() {
  return age;
}
public void setAge(int age) {
  this.age = age;
}
public Classroom getClassroom() {
  return classroom;
}
public void setClassroom(Classroom classroom) {
  this.classroom = classroom;
}
public Student(int id, String name, int age, Classroom classroom) {
  super();
  this.id = id;
  this.name = name;
  this.age = age;
  this.classroom = classroom;
}
public Student() {
  super();
}

}

教室类
public class Classroom {
private int id;
private String name;
private int grade;
public int getId() {
  return id;
}
public void setId(int id) {
  this.id = id;
}
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}
public int getGrade() {
  return grade;
}
public void setGrade(int grade) {
  this.grade = grade;
}
public Classroom(int id, String name, int grade) {
  super();
  this.id = id;
  this.name = name;
  this.grade = grade;
}
public Classroom() {
  super();
  // TODO Auto-generated constructor stub
}

}

测试类：

public class TestJaxb {

    public static void main(String[] args){
        TestJaxb.test02();
    }
@Test
public static void test01() {//测试对象转换xml字符串
  try {
   JAXBContext ctx = JAXBContext.newInstance(Student.class);
   Marshaller marshaller = ctx.createMarshaller();
   Student stu = new Student(1,"张三",21,new Classroom(1,"10计算机应用技术",2010));
   marshaller.marshal(stu, System.out);
  } catch (JAXBException e) {
   e.printStackTrace();
  }
}

@Test
public static void test02() {//测试xml字符串转换对象
  try {
   String xml = "212010110计算机应用技术1张三";
   JAXBContext ctx = JAXBContext.newInstance(Student.class);
   Unmarshaller um = ctx.createUnmarshaller();
   Student stu = (Student)um.unmarshal(new StringReader(xml));
   System.out.println(stu.getName()+","+stu.getClassroom().getName());
  } catch (JAXBException e) {
   e.printStackTrace();
  }

}
}

webservice的笔记

1简历webservice服务的步骤：

（1）服务器的建立：1：创建接口SEI（Service Endpoint Interface）

@WebService()

public interface IMyService
{

@WebResult(name="addResult")

public int add(@WebParam(name="a")int
a,@WebParam(name="b")int b);

@WebResult(name="minusResult")

public int minus(@WebParam(name="a")int
a,@WebParam(name="b")int b);

@WebResult(name="loginUser")

public User login(@WebParam(name="username")String
username,@WebParam(name="password")String password);

}

2：创建实现类SIB(Service inplemention Bean)

@WebService(endpointInterface="org.zttc.service.IMyService")

public class MyServiceImpl
implements IMyService {

@Override

public int add(int a, int b) {

System.out.println(a+"+"+b+"="+(a+b));

return a+b;

}

@Override

public int minus(int a, int b) {

System.out.println(a+"-"+b+"="+(a-b));

return a-b;

}

@Override

public User login(String username, String password) {

System.out.println(username+" is logining");

User user = new User();

user.setId(1);

user.setUsername(username);

user.setPassword(password);

return user;

}

3：开启服务

public class MyServer {

public
static void main(String[] args) {

String
address = "http://localhost:8888/ns";

Endpoint.publish(address,
new MyServiceImpl());

}

在浏览器地址栏中输入; http://localhost:8888/ns?wsdl,看到页面上出现xml文件。

（2）客户端的建立：

public class TestClient {

public
static void main(String[] args) {

try
{

创建访问wsdl服务地址的url

URL
url = new URL("http://localhost:8888/ns?wsdl");

通过qname指明服务的具体信息

QName
sname = new QName("http://service.zttc.org/",
"MyServiceImplService");

创建服务

Service
service = Service.create(url,sname);

实现接口

IMyService
ms = service.getPort(IMyService.class);

System.out.println(ms.add(12,33));

}
catch (MalformedURLException e) {

e.printStackTrace();

}

3.wsdl的有关参数：

types:用来定义访问的类型

message:SOAP

portType:指明服务器的接口，并且通过operation绑定相应的in和out的消息：其中in表示参数，out表示返回值

binding：指定传递消息所使用的格式

service：指定服务所发布的名称

4：dtd的例子：

classroom.dtd

encoding="UTF-8"?>

(claName,grade,students)>

classroom.xml

encoding="UTF-8"?>

"classroom.dtd">

10计算机应用技术

2010

zhangsan

lisi

122

js笔记

1.得到访问的文件地址

得到window中所有的事件

方法参数数组

null的类型

javascript技巧

1 Javascript数组转换为CSV格式

首先考虑如下的应用场景,有一个Javscript的字符型(或者数值型)数组,现在需要转换为以逗号分割的CSV格式文件。则我们可以使用如下的小技巧，代码如下：

     
     
     
     
      
      
      
      var fruits = ['apple', 'peaches', 'oranges', 'mangoes']; 

      
      
      
      　var str = fruits.valueOf();

输出：apple,peaches,oranges,mangoes

其中，valueOf()方法会将Javascript数组转变为逗号隔开的字符串。要注意的是，如果想不使用逗号分割，比如用｜号分割，则请使用join方法，如下：

     
     
     
     
      
      
      
      var fruits = ['apple', 'peaches', 'oranges', 'mangoes'];  

      
      
      
      var str = fruits.join("|");

输出： apple|peaches|oranges|mangoes

2 将CSV格式重新转换回Javscript数组

那么如何将一个CSV格式的字符串转变回Javascript数组呢？可以使用split()方法，就可以使用任何指定的字符去分隔，代码如下：

     
     
     
     
      
      
      
      var str = "apple, peaches, oranges, mangoes";   

      
      
      
      　var fruitsArray = str.split(",");

输出 fruitsArray[0]: apple

3 根据索引移除数组中的某个元素

假如需要从Javascript数组中移除某个元素，可以使用splice方法，该方法将根据传入参数n，移除数组中移除第n个元素(Javascript数组中从第0位开始计算)。

     
     
     
     
      
      
      
      function removeByIndex(arr, index) { 
      
      
      
          arr.splice(index, 1); 
      
      
      
      } 
      
      
      
      test = new Array(); 
      
      
      
      test[0] = 'Apple'; 
      
      
      
      test[1] = 'Ball'; 
      
      
      
      test[2] = 'Cat'; 
      
      
      
      test[3] = 'Dog'; 
      
      
      
      alert("Array before removing elements: "+test); 
      
      
      
      removeByIndex(test, 2); 
      
      
      
      alert("Array after removing elements: "+test);

则最后输出的为Apple,Ball,Dog

4 根据元素的值移除数组元素中的值

下面这个技巧是很实用的，是根据给定的值去删除数组中的元素，代码如下：

     
     
     
     
      
      
      
      function removeByValue(arr, val) { 
      
      
      
          for(var i=0; i
      
      
      
      
        if(arr[i] == val) { 
      
      
      
                  arr.splice(i, 1); 
      
      
      
                  break; 
      
      
      
              } 
      
      
      
          } 
      
      
      
      } 
      
      
      
      var somearray = ["mon", "tue", "wed", "thur"] 
      
      
      
      removeByValue(somearray, "tue"); 
      
      
      
      //somearray 将会有的元素是 "mon", "wed", "thur"

当然，更好的方式是使用prototype的方法去实现，如下代码：

     
     
     
     
      
      
      
      Array.prototype.removeByValue = function(val) { 
      
      
      
          for(var i=0; i
      
      
      
      
        if(this[i] == val) { 
      
      
      
                  this.splice(i, 1); 
      
      
      
                  break; 
      
      
      
              } 
      
      
      
          } 
      
      
      
      } 
      
      
      
      //.. 
      
      
      
      var somearray = ["mon", "tue", "wed", "thur"] 
      
      
      
      somearray.removeByValue("tue");

5 通过字符串指定的方式动态调用某个方法

有的时候，需要在运行时，动态调用某个已经存在的方法，并为其传入参数。这个如何实现呢？下面的代码可以：

     
     
     
     
      
      
      
      var strFun = "someFunction"; //someFunction 为已经定义的方法名 
      
      
      
      var strParam = "this is the parameter"; //要传入方法的参数   
      
      
      
      var fn = window[strFun]; 
      
      
      
      //调用方法传入参数 
      
      
      
      fn(strParam);

6 产生1到N的随机数

     
     
     
     
      
      
      
      var random = Math.floor(Math.random() * N + 1); 
      
      
      
      //产生1到10之间的随机数 
      
      
      
      var random = Math.floor(Math.random() * 10 + 1); 
      
      
      
      //产生1到100之间的随机数 
      
      
      
      var random = Math.floor(Math.random() * 100 + 1);

7 捕捉浏览器关闭的事件

我们经常希望在用户关闭浏览器的时候，提示用户要保存尚未保存的东西，则下面的这个Javascript技巧是十分有用的，代码如下：

就是编写onbeforeunload()事件的代码即可

8 检查是否按了回退键

同样，可以检查用户是否按了回退键，代码如下：

     
     
     
     
      
      
      
      window.onbeforeunload = function() {  
      
      
      
          return "You work will be lost.";  
      
      
      
      };

9 检查表单数据是否改变

有的时候，需要检查用户是否修改了一个表单中的内容，则可以使用下面的技巧，其中如果修改了表单的内容则返回true，没修改表单的内容则返回false。代码如下：

     
     
     
     
      
      
      
      function formIsDirty(form) { 
      
      
      
        for (var i = 0; i < form.elements.length; i++) { 
      
      
      
          var element = form.elements[i]; 
      
      
      
          var type = element.type; 
      
      
      
          if (type == "checkbox" || type == "radio") { 
      
      
      
            if (element.checked != element.defaultChecked) { 
      
      
      
              return true; 
      
      
      
            } 
      
      
      
          } 
      
      
      
          else if (type == "hidden" || type == "password" || 
      
      
      
                   type == "text" || type == "textarea") { 
      
      
      
            if (element.value != element.defaultValue) { 
      
      
      
              return true; 
      
      
      
            } 
      
      
      
          } 
      
      
      
          else if (type == "select-one" || type == "select-multiple") { 
      
      
      
            for (var j = 0; j < element.options.length; j++) { 
      
      
      
              if (element.options[j].selected != 
      
      
      
                  element.options[j].defaultSelected) { 
      
      
      
                return true; 
      
      
      
              } 
      
      
      
            } 
      
      
      
          } 
      
      
      
        } 
      
      
      
        return false; 
      
      
      
      } 
      
      
      
      window.onbeforeunload = function(e) { 
      
      
      
        e = e || window.event;   
      
      
      
        if (formIsDirty(document.forms["someForm"])) { 
      
      
      
          // IE 和 Firefox 
      
      
      
          if (e) { 
      
      
      
            e.returnValue = "You have unsaved changes."; 
      
      
      
          } 
      
      
      
          // Safari浏览器 
      
      
      
          return "You have unsaved changes."; 
      
      
      
        } 
      
      
      
      };

10 完全禁止使用后退键

下面的技巧放在页面中，则可以防止用户点后退键，这在一些情况下是需要的。代码如下：

     
     
     
     
      
      
      
       
      
      
      
       
      
      
      
      
      
      
      
      
    οnpageshοw="if (event.persisted) noBack();" οnunlοad="">

11 删除用户多选框中选择的项目

下面提供的技巧，是当用户在下拉框多选项目的时候，当点删除的时候，可以一次删除它们，代码如下：

     
     
     
     
      
      
      
      function selectBoxRemove(sourceID) { 

      
      
      
          //获得listbox的id 
      
      
      
          var src = document.getElementById(sourceID); 

      
      
      
          //循环listbox 
      
      
      
          for(var count= src.options.length-1; count >= 0; count--) { 

      
      
      
               //如果找到要删除的选项，则删除 
      
      
      
              if(src.options[count].selected == true) { 

      
      
      
                      try { 
      
      
      
                               src.remove(count, null); 
      
      
      
                       } catch(error) { 
      
      
      
                               src.remove(count); 
      
      
      
                      } 
      
      
      
              } 
      
      
      
          } 
      
      
      
      }

12 Listbox中的全选和非全选

如果对于指定的listbox，下面的方法可以根据用户的需要，传入true或false,分别代表是全选listbox中的所有项目还是非全选所有项目，代码如下：

     
     
     
     
      
      
      
      function listboxSelectDeselect(listID, isSelect) { 
      
      
      
          var listbox = document.getElementById(listID); 
      
      
      
          for(var count=0; count < listbox.options.length; count++) { 
      
      
      
                  listbox.options[count].selected = isSelect; 
      
      
      
          } 
      
      
      
      }

13 在Listbox中项目的上下移动

下面的代码，给出了在一个listbox中如何上下移动项目

     
     
     
     
      
      
      
      unction listbox_move(listID, direction) { 
      
      
      
          var listbox = document.getElementById(listID); 
      
      
      
          var selIndex = listbox.selectedIndex; 
      
      
      
          if(-1 == selIndex) { 
      
      
      
              alert("Please select an option to move."); 
      
      
      
              return; 
      
      
      
          } 
      
      
      
          var increment = -1; 
      
      
      
          if(direction == 'up') 
      
      
      
              increment = -1; 
      
      
      
          else 
      
      
      
              increment = 1; 
      
      
      
          if((selIndex + increment) < 0 || 
      
      
      
              (selIndex + increment) > (listbox.options.length-1)) { 
      
      
      
              return; 
      
      
      
          } 
      
      
      
          var selValue = listbox.options[selIndex].value; 
      
      
      
          var selText = listbox.options[selIndex].text; 
      
      
      
          listbox.options[selIndex].value = listbox.options[selIndex + increment].value 
      
      
      
          listbox.options[selIndex].text = listbox.options[selIndex + increment].text 
      
      
      
          listbox.options[selIndex + increment].value = selValue; 
      
      
      
          listbox.options[selIndex + increment].text = selText; 
      
      
      
          listbox.selectedIndex = selIndex + increment; 
      
      
      
      } 
      
      
      
      //.. 
      
      
      
      //.. 
      
      
      
      listbox_move('countryList', 'up'); //move up the selected option 
      
      
      
      listbox_move('countryList', 'down'); //move down the selected option

14 在两个不同的Listbox中移动项目

如果在两个不同的Listbox中，经常需要在左边的一个Listbox中移动项目到另外一个Listbox中去，下面是相关代码：

     
     
     
     
      
      
      
      function listbox_moveacross(sourceID, destID) { 
      
      
      
          var src = document.getElementById(sourceID); 
      
      
      
          var dest = document.getElementById(destID); 
      
      
      
          for(var count=0; count < src.options.length; count++) { 
      
      
      
              if(src.options[count].selected == true) { 
      
      
      
                      var option = src.options[count]; 
      
      
      
                      var newOption = document.createElement("option"); 
      
      
      
                      newOption.value = option.value; 
      
      
      
                      newOption.text = option.text; 
      
      
      
                      newOption.selected = true; 
      
      
      
                      try { 
      
      
      
                               dest.add(newOption, null); //Standard 
      
      
      
                               src.remove(count, null); 
      
      
      
                       }catch(error) { 
      
      
      
                               dest.add(newOption); // IE only 
      
      
      
                               src.remove(count); 
      
      
      
                       } 
      
      
      
                      count--; 
      
      
      
              } 
      
      
      
          } 
      
      
      
      } 
      
      
      
      //.. 
      
      
      
      //.. 
      
      
      
      listbox_moveacross('countryList', 'selectedCountryList');

15 快速初始化Javscript数组

下面的方法，给出了一种快速初始化Javscript数组的方法，代码如下：

     
     
     
     
      
      
      
      var numbers = []; 
      
      
      
      for(var i=1; numbers.push(i++)<100;); 
      
      
      
      //numbers = [0,1,2,3 ... 100] 
      
      
      
      使用的是数组的push方法

16 截取指定位数的小数

如果要截取小数后的指定位数，可以使用toFixed方法，比如：

     
     
     
     
      
      
      
      var num = 2.443242342; 
      
      
      
      　alert(num.toFixed(2)); // 2.44 
      
      
      
      而使用toPrecision(x)则提供指定位数的精度，这里的x是全部的位数，如： 
      
      
      
      num = 500.2349; 
      
      
      
      　result = num.toPrecision(4);//输出500.2

17 检查字符串中是否包含其他字符串

下面的代码中，可以实现检查某个字符串中是否包含其他字符串。代码如下：

     
     
     
     
      
      
      
      if (!Array.prototype.indexOf) {  
      
      
      
          Array.prototype.indexOf = function(obj, start) { 
      
      
      
               for (var i = (start || 0), j = this.length; i < j; i++) { 
      
      
      
                   if (this[i] === obj) { return i; } 
      
      
      
               } 
      
      
      
               return -1; 
      
      
      
          } 
      
      
      
      } 
      
      
      
      if (!String.prototype.contains) { 
      
      
      
          String.prototype.contains = function (arg) { 
      
      
      
              return !!~this.indexOf(arg); 
      
      
      
          }; 
      
      
      
      }

在上面的代码中重写了indexOf方法并定义了contains方法，使用的方法如下：

     
     
     
     
      
      
      
      var hay = "a quick brown fox jumps over lazy dog"; 
      
      
      
      var needle = "jumps"; 
      
      
      
      alert(hay.contains(needle));

18 去掉Javscript数组中的重复元素

下面的代码可以去掉Javascript数组中的重复元素，如下：

     
     
     
     
      
      
      
      function removeDuplicates(arr) { 
      
      
      
          var temp = {}; 
      
      
      
          for (var i = 0; i < arr.length; i++) 
      
      
      
              temp[arr[i]] = true; 
      
      
      
          var r = []; 
      
      
      
          for (var k in temp) 
      
      
      
              r.push(k); 
      
      
      
          return r; 
      
      
      
      } 
      
      
      
      //用法 
      
      
      
      var fruits = ['apple', 'orange', 'peach', 'apple', 'strawberry', 'orange']; 
      
      
      
      var uniquefruits = removeDuplicates(fruits); 
      
      
      
      //输出的 uniquefruits ['apple', 'orange', 'peach', 'strawberry'];

19 去掉String中的多余空格

下面的代码会为String增加一个trim()方法，代码如下：

     
     
     
     
      
      
      
      if (!String.prototype.trim) { 
      
      
      
         String.prototype.trim=function() { 
      
      
      
          return this.replace(/^\s+|\s+$/g, ''); 
      
      
      
         }; 
      
      
      
      } 
      
      
      
      //用法 
      
      
      
      var str = "  some string    "; 
      
      
      
      str.trim(); 
      
      
      
      //输出 str = "some string"

20 Javascript中的重定向

在Javascript中，可以实现重定向，方法如下：

     
     
     
     
      
      
      
      window.location.href = "http://viralpatel.net";

21 对URL进行编码

有的时候，需要对URL中的传递的进行编码，方法如下：

     
     
     
     
      
      
      
      var myOtherUrl =  
      
      
      
             "http://example.com/index.html?url=" + encodeURIComponent(myUrl);

jquery得到radio单选框的值

       name1

name2



   $(document).ready(function(){
    $("#Btn_riskLib").bind("click",function(){
                    var id =$(":radio:checked").val();
                    if(id==null){
                        alert("请选择一个!");

                    }else {
      alert(id);
     }
  })
   });

jpa 多对多查询hql语句

任务和联系人是多对多关系，现在由联系人id查询出所有相关的任务
"SELECT t from Task t join t.contacters c where c.id = ?1"

比如：

一个老师教许多学生,一个学生被许多老师教,一个学生有好多书,同一种书被许多同学拥有.
要查询教拥有书"a"的学生的老师!

Hql语句：

SELECT t FROM Teacher t join t.students s join s.books b where b.name = 'a'

解释：t.students s中s并不是集合的意思,而是t的students对象的表别名,join t.students s这个hql,hibernate会翻译成两个表的内连接关系

错误写法：

SELECT t FROM teacher t where t.students.books.name = 'a'

其实道理是很显然的,t.students是一个Set,那么这个Set怎么可能有books这样的属性呢?同理books.name也不对,所以使用表间连接并给出别名t.students s,此时的对象s才有books属性,所以可以写s.books b,最后使用b.name限制查询b.name = 'a'.

另外一种写法：

SELECT t FROM Teacher t,Student s,Book b where s.id in elements(t.students) and b.id in elements(s.books)
这种方法没有出错!不过这种方式要用子查询!

java--dom读取xml文件

public Map readXml() {
 try {
 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 DocumentBuilder builder = dbf.newDocumentBuilder();
 Document doc;
 InputStream stream = this.getClass().getResourceAsStream("/dictionaries.xml");
 doc = builder.parse(stream);
 Element root = doc.getDocumentElement();
 NodeList list = root.getElementsByTagName("dictionary");
 Map map = new LinkedHashMap();
 ArrayList types = new ArrayList();
 for (int i = 0; i < list.getLength(); i++) {
 String key = list.item(i).getAttributes().getNamedItem("name").getNodeValue();
 String value = list.item(i).getAttributes().getNamedItem("value").getNodeValue();
 map.put(key, value);
 }
 return map;
 } catch (Exception ex) {
 return null;
 }

}

dictionaries.xml文件如下：

jquery添加节点和删除节点例子

dddddddd

jquery创建节点元素

dddddddd

javascript取得表单对象的几种方法

javascript鼠标和键盘事件和关闭浏览器时的提示语

javascript得到事件和元素的跨浏览器方法

1111111111

2222222222

  163
  普通按钮，不跳转

javascript事件对象event

在非ie中

1111111111

2222222222

  163
  普通按钮，不跳转


在ie中

1111111111

2222222222

  163
  普通按钮，不跳转

javascript跨浏览器事件

1111111111

2222222222

javascript冒泡事件和捕获事件

JavaScript 的事件是以一种流的形式存在的，一个事件会有多个元素同时响应。有时候这不是我们想要的，我们只需要某个特定的元素响应我们的绑定事件就可以了。

事件分类
捕获型事件（非IE）、冒泡型事件（所有浏览器都支持）
捕获型事件是自上而下的，而冒泡型事件是自下而上的。下面我用一个图来直观表示：

冒泡型事件我们在工作中可能会比较多遇到，但捕获型事件怎样才会执行到呢，如果我们想要在非 IE 浏览器中要创建捕获型事件，只需将 addEventListener 的第三个参数设为true就好了。

第三个参数false代表在冒泡时运行，true代表在捕获时运行。

ID为div1和div2的两个元素都被绑定了捕捉阶段的事件处理函数，这样：

当点击#div1（蓝色区域）时，应该会alert出”div1″ 当点击#div2（黄色区域）时，应该会先alert出”div1″，再alert出”div2″，因为在事件捕捉阶段，事件是从根元素向下传播的，#div1是#div2的父元素，自然绑定在#div1上的click事件也会先于#div2上的click事件被执行。

冒泡事件 var i = 1; function Add(sText,objText) { document.getElementById("Console").innerHTML +=sText + "执行顺序：" + i + "" + ""; i = i + 1; //window.event.cancelBubble = true; } 事件触发','body')"> 事件触发','div')"> 事件触发','p')" style="background:#c00;">点击

从这个例子我们可以很清楚的看到事件冒泡是从目标元素 P 一直上升到 body 元素。
例子：

1111111111

2222222222

javascript操作css

在javascript操作css中，如果css的属性是比如background-color中间有横线的，在javascript操作是要遵守驼峰命名法，如mydiv.style.backgroundColor='blue';

在点击让图片显示和隐藏时css中style.visibility=’hidden’,让图片隐藏但是不释放空间，style.display=’none’,图片隐藏并且释放空间，style.display=’block’,图片显示，style.visibility=’visible’,图片显示。
一个定时不断改变颜色的例子：

数据库并发

http://soft.zdnet.com.cn/software_zone/2007/0607/407592.shtml

javascript数组方法

java排序

package com.test.yjw;

public class Sort {

//冒泡
/**
*
*/
public static void bubbleSort(int a[]) {
 int len = a.length;
 for (int i = 0; i < len - 1; i++) {
 for (int j = 0; j < len - 1 - i; j++) {
 if (a[j] > a[j + 1]) {
 int temp = a[j];
 a[j] = a[j + 1];
 a[j + 1] = temp;
 }
 }
 }
 for(int t : a){
 System.out.println(t);
 }
}
//选择排序
public static void selectSort(int a[]) {
 int temp = 0;
 int len = a.length;
 for (int i = 0; i < len - 1; i++) {
 int min = a[i];
 int index = i;
 for (int j = i + 1; j < len; j++) {
 if (min > a[j]) {
 min = a[j];
 index = j;
 }
 }
 temp = a[i];
 a[i] = a[index];
 a[index] = temp;
 }
 for(int t : a){
 System.out.println(t);
 }
}
// 插入排序{9,5,1,3,7,8,6,2,0,4}
public static void insertSort(int a[]) {
 int len = a.length;
 for (int i = 1; i < len; i++) {
 int temp = a[i];// 待插入的值
 int index = i;// 待插入的位置
 while (index > 0 && a[index - 1] > temp) {
 a[index] = a[index - 1];// 待插入的位置重新赋更大的值
 index--;// 位置往前移
 }
 a[index] = temp;
 }
 for(int t : a){
 System.out.println(t);
 }
}
//快速排序
public static void quickSort(int a[], int low, int height) {
 if (low < height) {
 int result = partition(a, low, height);
 quickSort(a, low, result - 1);
 quickSort(a, result + 1, height);
 }

}
public static int partition(int a[], int low, int height) {
 int key = a[low];
 while (low < height) {
 while (low < height && a[height] >= key)
 height--;
 a[low] = a[height];
 while (low < height && a[low] <= key)
 low++;
 a[height] = a[low];
 }
 a[low] = key;
 return low;
}
public static void swap(int a[], int i, int j) { // 通过临时变量,交换数据
 int tmp = a[i];
 a[i] = a[j];
 a[j] = tmp;
 } // 第一次交换分析
 public static void quicksort(int a[], int low, int high) { // 假设传入low=0; high=a.length-1;
 if (low < high) { // 条件判断
 int pivot, p_pos, i; // 声明变量
 p_pos = low; // p_pos指向low,即位索引为0位置 ;
 pivot = a[p_pos]; // 将0位置上的数值赋给pivot;
 for (i = low + 1; i <= high; i++) { // 循环次数, i=1;
 if (a[i]>pivot) { // 1位置的数与0位置数作比较: a[1]>a[0]
 p_pos++; // 2位与1位比较,3位与2位比较......
 swap(a, p_pos, i); // 传参并调用swap
 }
 }
 swap(a, low, p_pos); // 将p_pos设为high再次调用swap
 quicksort(a, low, p_pos - 1); // 递归调用,排序左半区
 quicksort(a, p_pos + 1, high); // 递归调用,排序右半区
 }

 }

public static void main(String[] args) {
 int[] a =new int[]{9,5,1,3,7,8,6,2,0,4};
 //Sort.bubbleSort(a);
 //Sort.selectSort(a);
 //Sort.insertSort(a);
 Sort.quickSort(a, 0, a.length-1);
 for(int t : a){
 System.out.println(t);
 }
}
}

java io

在java语言 I/O库的设计中，使用了两个结构模式，即装饰模式和适配器模式。
      在任何一种计算机语言中，输入/输出都是一个很重要的部分。与一般的计算机语言相比，java将输入/输出的功能和使用范畴做了很大的扩充。因此输入输出在java语言中占有极为重要的位置。
      java语言采用流的机制来实现输入/输出。所谓流，就是数据的有序排列，流可以是从某个源（称为流源，或者 Source of Stream）出来，到某个目的（Sink of Stream）地去。根据流的方向可以将流分成输出流和输入流。程序通过输入流读取数据，想输出流写出数据。
     例如：一个java程序可以使用FileInputStream类从一个磁盘文件读取数据，如下图：

      像FileInputStream这样的处理器叫流处理器。一个流处理器就像一个流的管道一样，从一个流源吸入某种类型的数据，并输出某种类型的数据。上面的示意图叫流的管道图。

     类似地，也可以用FileOutputStream类向一个磁盘文件写数据，如下图：

     在实际的应用当中，这样简单的机制并没有太大的用处。程序需要写出的往往是非常结构话的信息，因此这些Byte类型的数据实际上是一些数字、文字、源代码等。java的I/O库提供了一个称作链接（Chaining）的机制，可以将一个流处理器与另一个流处理器首尾相接，以其中之一的输出为输入，形成一个流管道的链接。

      例如,DateInputStream流处理器可以把FileInputStream流对象的输出当做输入，将Byte类型的数据转换成java的原始数据类型和String数据类型，如下图：

       类似地，向一个文件中写入Byte类型的数据也不是一个简单的过程。一个程序需要向一个文件里写入的数据往往是结构化的，而Byte类型则是原始的类型，因此，在写入的时候必须首先经过转换。DateOutputStream流处理器提供了接受原始数据类型和String数据类型的方法，而这个流处理器的输出数据则是Byte类型。换而言之，DateOutputStream可以将源数据转换成Byte类型的数据，在输出出来。

      这样一来，就可以将DateOutputStream与FileOutputStream链接起来。这样做的结果就是，程序可以将原始数据类型和String数据类型的源数据写到这个链接好的双重管道里面，达到将结构话数据写到磁盘文件里的目的，如下图所示：

      这是链接的威力。

     流处理器所处理的流必定都有流源，如果将流类所处理的流源分类的话，那么基本可以分成两大类：

   （1）数组、String、File等，这一种叫原始流源。

   （2）同样类型的流用做链接流类的流源，就叫做链接流源。

java I/O库的设计原则

java语言的I/O库是对各种常见的流源、流汇以及处理过程的抽象化。客户端的java 程序不必知道最终的的流源、流汇是磁盘上的文件还是一个数组，或者是一个线程；也不比插手到诸如数据是否缓存、可否按照行号读取等处理的细节中去。

要理解java I/O 这个庞大而复杂的库，关键是掌握两个对称性和两个设计模式。

java I/O库的两个对称性

      java I/O库具有两个对称性，它们分别是：

     （1）输入-输出对称：比如InputStream 和OutputStream 各自占据Byte流的输入和输出的两个平行的等级结构的根部；而Reader和Writer各自占据Char流的输入和输出的两个平行的等级结构的根部。

     （2）byte-char对称：InputStream和Reader的子类分别负责byte和插入流的输入；OutputStream和Writer的子类分别负责byte和Char流的输出，它们分别形成平行的等级结构。

java I/O库的两个设计模式

      ava I/O库的总体设计是符合装饰模式和适配器模式的。如前所述，这个库中处理流的类叫流类。

      装饰模式：在由InputStream、OutputStream、Reader和Writer代表的等级结构内部，有一些流处理器可以对另一些流处理器起到装饰作用，形成新的、具有改善了的功能的流处理器。

     适配器模式：在由InputStream、OutputStream、Reader和Writer代表的等级结构内部，有一些流处理器是对其他类型的流处理器的适配。这就是适配器的应用。

装饰模式的应用

      装饰模式在java中的最著名的应用莫过于java I/O标准库的设计了。

      由于java I/O库需要很多性能的各种组合，如果这些性能都是用继承来实现，那么每一种组合都需要一个类，这样就会造成大量行重复的类出现。如果采用装饰模式，那么类的数目就会大大减少，性能的重复也可以减至最少。因此装饰模式是java I/O库基本模式。

      装饰模式的引进，造成灵活性和复杂性的提高。因此在使用 java I/O 库时，必须理解java I/O库是由一些基本的原始流处理器和围绕它们的装饰流处理器所组成的。

InputStream类型中的装饰模式

InputStream有七个直接的具体子类，有四个属于FilterInputStream的具体子类，如下图所示：

上图中所有的类都叫做流处理器，这个图叫做（InputStream类型）流处理器图。根据输入流的源的类型，可以将这些流分为两种，即原始流类和链接流处理器。

原始流处理器

      原始流处理器接收一个Byte数组对象、String对象、FileDescriptor对象或者不同类型的流源对象（就是前面所说的原始流源），并生成一个InputStream类型的流对象。在InputStream类型的流处理器中，原始流处理器包括以下四种：
    （1）ByteArrayInputStream：为多线程的通讯提供缓冲区操作工作，接受一个Byte数组作为流的源。
    （2）FileInputStream：建立一个与文件有关的输入流。接受一个File对象作为流的源。
    （3）PipedInputStream：可以和PipedOutputStream配合使用，用于读入一个数据管道的数据。接受一个PipedOutputStream作为源。
    （4）StringBufferInputStream：将一个字符串缓冲区抓换为一个输入流。接受一个String对象作为流的源。
      与原始流处理器相对应的是链接流处理器。

链接流处理器

       所谓链接流处理器就是可以接受另一个（同种类的）流对象（就是链接流源）作为流源，并对之进行功能扩展的类。InputStream类型的链接流处理器包括以下几种，它们接受另一个InputStream对象作为流源。

     （1）FilterInputStream称为过滤输入流，它将另一个输入流作为流源。这个类的子类包括以下几种：
         BufferInputStream：用来从硬盘将数据读入到一个内存缓冲区中，并从此缓冲区提供数据。
         DateInputStream：提供基于多字节的读取方法，可以读取原始数据类型的数据。
         LineNumberInputStream：提供带有行计算功能的过滤输入流。
         PushbackInputStream： 提供特殊的功能，可以将已读取的直接“推回”输入流中。
     （2）ObjectInputStream 可以将使用ObjectInputStream串行化的原始数据类型和对象重新并行化。
     （3）SequenceInputStream可以将两个已有的输入流连接起来，形成一个输入流，从而将多个输入流排列构成一个输入流序列。
     必须注意的是，虽然PipedInuptStream接受一个流对象PipedOutputStream作为流的源，但是PipedOutputStream流对象的类型不是InputStream，因此PipedInputStream流处理器仍属于原始流处理器。

抽象结构图

上面流处理器图与装饰模式的结构图有明显的相同之处。实际上InputStream类型的流处理器结构确实符合装饰模式，而这可以从它们在结构中所扮演的角色中分辩出来。

装饰模式的各个角色

      在所有InputStream类型的链接流处理其中，使用频率最大的就是FilterInputStream类，以这个类为抽象装饰角色的装饰模式结构非常明显和典型。以这个类为核心说明装饰模式的各个角色是由哪些流处理器扮演：
       抽象构件（Component）角色：由InputStream扮演。这是一个抽象类，为各种子类型处理器提供统一的接口。
       具体构建（Concrete Component）角色：由ByteArrayInputStream、FileInputStream、PipedInputStream以及StringBufferInputStream等原始流处理器扮演。它们实现了抽象构建角色所规定的接口，可以被链接流处理器所装饰。
       抽象装饰（Decorator）角色：由FilterInputStream扮演。它实现了InputStream所规定的接口。
       具体装饰（Concrete Decorator）角色：由几个类扮演，分别是DateInputStream、BufferedInputStream 以及两个不常用到的类LineNumberInputStream和PushbackInputStream。
      链接流其实就是装饰角色，原始流就是具体构建角色，如下图所示：

一方面，链接流对象接受一个（同类型的）原始流对象或者另一个（同类型的）链接流对象作为流源；另一方面，它们都对流源对象的内部工作方法做了相应的改变，这种改变是装饰模式所要达到的目的。比如：
（1）BufferedInputStream “装饰” 了InputStream的内部工作方式，使得流的读入操作使用缓冲机制。在使用了缓冲机制后，不会对每一次的流读入操作都产生一个物理的读盘动作，从而提高了程序的效率。在涉及到物理流的读入时，都应当使用这个装饰流类。
（2）LineNumberInputStream和PushbackInputStream也同样“装饰”了InputStream的内部工作方式，前者使得程序能够按照行号读入数据；后者能使程序在读入的过程中退后一个字符。后两个装饰类可能在实际的编程工作中很少用到，因为它们是为了支持用java语言做编译器而准备的。
（3）DateInputStream子类读入各种不同的原始数据类型以及String类型的数据，这一点可以从它提供的各种read()方法看出来： readByte()、readUnsignedByte()、readShort()、readUnsignedShort()、readChar()、readInt()、readLong()、readFloat()、readDouble()、readUTF()。使用这个流处理器以及它的搭档DateOutputStream，可以将原始数据通过流从一个地方移到另一个地方。

OutputStream 类型中的装饰模式

outputStream是一个用于输出的抽象类，它的接口、子类的等级结构、子类的功能都和InputStream有很好的对称性。在OutputStream给出的接口里，将write换成read就得到了InputStream的接口，而其具体子类则在功能上面是平行的。
（1）针对byte数字流源的链接流类，以ByteArrayInputStream描述输入流，以ByteArrayOutputStream描述输出流。
（2）针对String流源的链接流类，以StringBufferInputStream描述输入流，以StringBufferOutputStream描述输出流。
（3）针对文件流源的链接流类，以FileInputStream描述输入流，以FileOutputStream描述输出流。
（4）针对数据管道流源的链接流类，以PipedInputStream描述输入流，以PipedOutputStream描述输出流。
（5）针对以多个流组成的序列，以SequenceInputStream描述输入流，以SequenceOutputStream描述输出流。

OutputStream类型有哪些子类

outputStream有5个直接的具体子类，加上三个属于FilterInputStream的具体子类，一共有8个具体子类，如下图：

原始流处理器

在OutputStream类型的流处理器中，原始流处理器包括以下三种：
ByteArrayOutputStream：为多线程的通信提供缓冲区操作功能。输出流的汇集是一个byte数组。
FileOutputStream：建立一个与文件有关的输出流。输出流的汇集是一个文件对象。
PipedOutputStream： 可以与PipedInputStream配合使用，用于向一个数据管道输出数据。

链接流处理器

OutputStream类型的链接流处理器包括以下几种：
（1）FilterOutputStream：称为过滤输出流，它将另一个输出流作为流汇。这个类的子类有如下几种：
BufferedOutputStream：用来向一个内存缓冲区中写数据，并将此缓冲区的数据输入到硬盘中。
DataOutputStream：提供基于多字节的写出方法，可以写出原始数据类型的数据。
PrintStream：用于产生格式化输出。System.out 静态对象就是一个PrintStream。
（2）ObjectOutputStream 可以将原始数据类型和对象串行化。

装饰模式的各个角色

在所有的链接流处理器中，最常见的就是FilterOutputStream类。以这个类为核心的装饰模式结构非常明显和典型，如下图：

装饰模式所涉及的各个角色：
   抽象构件（Component）角色：由OutputStream扮演，这是一个抽象类，为各种的子类型流处理器提供统一的接口。
   具体构件（Concrete Component）角色：由ByteArrayOutputStream、FileOutputStream、PipedOutputStream等扮演，它们均实现了OutputStream所声明的接口。
   抽象装饰（Decorator）角色：由FilterOutputStream扮演，它与OutputStream有相同的接口，而这正是装饰类的关键。
   具体装饰（Concrete Decorator）角色：由几个类扮演，分别是BufferedOutputStream、DateOutputStream、以及PrintStream。
   所谓链接流，就是装饰模式中的装饰角色，原始流就是具体构件角色。
  与DateInputStream相对应的是DataOutputStream，后者负责将由原始数据类型和String对象组成的数据格式化，并输出到一个流中，使得任何机器上的任何DataInputStream类型的对象都可以读入这些数据。所有的方法都是以write开始。
如果需要对数据进行真正的格式化，以便输出到像控制台显示那样，那就需要使用PrintStream。
PrintStream可以对由原始数据类型和String对象组成的数据进行格式化，以形成可以阅读的格式；而DataOutputStream则不同，它将数据输出到一个流中，以便DataInputStream可以在任何机器而后操作系统中都可以重新将数据读入，并进行结构重建。
PrintStream对象最重要的两个方法是print() 和println()，这两个方法都是重载的，以便可以打印出所有使用类型的数据。这两个方法之间的区别是后者每行结束时多打印出一个换行符号。
BufferedOutputStream对一个输出流进行装饰，使得流的写出操作使用缓冲机制。在使用缓冲机制后，不会对每一次的流的写入操作都产生一个物理的写动作，从而提高的程序的效率。在涉及到物理流的地方，比如控制台I/O、文件I/O等，都应当使用这个装饰流处理器。

Reader类型中的装饰模式

在Reader类型的流处理器中， 原始流处理器包括以下四种：
（1）CharArrayReader：为多线程的通信提供缓冲区操作功能。
（2）InputStreamReader：这个类有一个子类--FileReader。
（3）PipedReader：可以与PipedOutputStream配合使用，用于读入一个数据管道的数据。
    （4）StringReader：建立一个与文件有关的输入流。
      链接流处理器包括以下：
    （1）BufferedReader：用来从硬盘将数据读入到一个内存缓冲区，并从此缓冲区提供数据，这个类的子类为LineNumberReader。
    （2）FilterReader：成为过滤输入流，它将另一个输入流作为流的来源。这个类的子类有PushbackReader，提供基于多字节的读取方法，可以读取原始数据类型的数据，Reader类型的类图如下所示：

      Reader类型中，装饰模式所涉及的各个角色：
     （1）抽象构建（Component）角色：有Reader扮演。这是一个抽象类，为各种的子类型流处理器提供统一的接口。
     （2）具体构建（Concrete Component）角色：由CharArrayReader、InputStreamReader、PiPedReader、StringReader等扮演，他们均实现了Reader所声明的接口。
     （3）抽象装饰（Decorator）角色：由BufferedReader和FilterReader扮演。这两者有着与Reader相同的接口，它们分别给出两个装饰角色的等级结构，第一个给出LineNumberReader作为具体装饰角色，另一个给出PushbackReader 作为具体装饰角色。
     （4）具体装饰（Concrete Decorator）角色：LineNumberReader作为BufferedReader的具体装饰角色，BufferedReader作为FilterReader的具体装饰角色。
       如下图所示，标有聚合连线的就是抽象装饰角色：

Writer类型中的装饰模式

Writer类型是一个与Reader类型平行的等级结构，而且Writer类型的等级结构几乎与Reader的等级结构关于输入/输出是对称的。如图所示：

      在Writer类型的流处理器中，原始流处理器包括以下四种：
     （1）CharArrayWriter：为多线程的通信提供缓冲区的操作功能。
     （2）OutputStreamWriter：建立一个与文件有关的输出流。含有一个具体子类FileWrite，为Write类型的输出流提供文件输出功能。
     （3）PipedWriter：可以和PipedOutputStream配合使用，用于读如果一个数据管道的数据。
     （4）StringWriter：想一个StringBuffer写出数据。
       链接流处理器包括以下三种：
     （1）BufferedWriter：为Writer类型的流处理器提供缓冲区功能。
     （2）FilterWriter：称为过滤输入流，它将另一个输入流作为流的来源。这是一个没有子类的抽象类。
     （3）PrintWriter：支持格式化的文字输出。
      Writer类型中，装饰模式所涉及的各个角色：
     （1）抽象构建（Component）角色：由Write扮演。这是一个抽象类，为为各种子类型的流处理器提供统一的接口。
     （2）具体构建（Concrete Component）：角色由CharArrayWriter、OutputStreamWriter、
PipedWriter、StringWriter扮演，它们实现了Writer所声明的接口。
     （3）抽象装饰（Decorator）角色：由BufferedWriter、FilterWriter、PrintWriter扮演，它们有着与Write
相同的接口。
     （4）具体装饰（Concrete Decorator）角色：与抽象装饰角色合并。
如下图所示，标出了从抽象装饰角色到抽象构件角色的聚合连线，更易于与装饰模式的结构图比较。

适配器模式的应用

适配器模式是java I/O库中第二个最重要的设计模式。

InputStream原始流处理器中的适配器模式

InputStream类型的原始流处理器是适配器模式的应用。

ByteArrayInputStream是一个适配器类

ByteArrayInputStream继承了InputStream的接口，而封装了一个byte数组。换而言之，它将一个byte数组的接口适配成了InputStream流处理器的接口。
java语言支持四种类型：java类、java接口、java数组和原始类型。前三章是引用类型，类和数组的实例都是对象，原始类型的值不少对象。java语言的数组是像所有其他对象一样的对象，而不管数组中所存放的元素的类型是什么。这样一来，ByteArrayInputStream就符合适配器模式的描述，而且是一个对象形式的适配器类。如下图所示：

StringBufferInputStream是一个适配器类

StringBufferInputStream继承了InputStream类型，同时持有一个对String类型的引用。这是将String对象适配成InputStream类型的对象形式的适配器模式，如下图：

OutputStream原始流处理器中的适配器模式

在OutputStream类型中，所有的原始流处理器都是适配器类。
ByteArrayOutputStream是一个适配器类
ByteArrayOutputStream继承了OutputStream类型，同事持有一个对byte数组的引用。它把一个byte数组的接口适配成OutputStream类型的接口，因此也是一个对象类型的适配器模式的应用。如下图：

FileOutputStream是一个适配器类
FileOutputStream继承OutputStream，同时持有一个对FileDescriptor对象的引用。这是一个将FileDescriptor适配成OutputStream接口的对象形式的适配器模式，如下图所示：

PipedOutputStream是一个适配器类
PipedOutputStream总是和PipedInputStream一起使用，它接收一个类型为PipedInputStream的输入类型，并将之转换成OutputStream类型的输出流，这是一个对象形式的适配器模式应用。如下图：

Reader原始流处理器中的适配器模式
Reader 类型的原始流处理器都是适配器模式的应用。
CharArrayReader是一个适配器类。
CharArrayReader将一个Char数组适配成Reader类型的输入流，因此它是一个对象形式的适配器应用，如下图所示：

StringReader是一个适配器类
StringReader 继承了Reader类型，持有一个对String类型的引用。它将String的接口适配成Reader类型的接口，如下图所示：

Writer类型中的适配器模式
Writer类型中的原始流处理器就是适配器模式的具体应用。
CharArrayWriter是一个适配器类。
  CharArrayWriter将一个Char数组适配成Writer 接口，如下图所示：

PipedWriter是一个适配器类
PipedWriter总是与PiPedReader一同使用，它将一个PipedReader对象的接口适配成一个Writer类型的接口，如下图所示：

StringWriter是一个适配器类
StringWriter继承Writer类型，同时持有一个StringBuffer对象，它将StringBuffer对象的接口适配成为了
Writer类型的接口，是一个对象形式的适配器模式的应用，如下图所示：

从byte流到char流的适配

在java语言的标准库 java I/O 里面，有一个InputStreamReader类叫做桥梁（bridge）类。InputStreamReader是从byte流到char流的一个桥梁，它读入byte数据并根据指定的编码将之翻译成char数据。
InputStreamReader虽然叫“桥梁”，但它不爽桥梁模式，是适配器模式的应用。

InputStreamReader

InputStreamReader是从byte输入流到char输入流的一个适配器。下图所示就是InputStreamReader 的结构图：

为了说明适配器类InputStreamReader是如何使用，请看下面例子。Echo类可以将控制台输入的任何字符串从新打印出来，源代码如下：
Echo.java

view sourceprint?

`01`	`package` `com.think.cla;`

02

`03`	`import` `java.io.BufferedReader;`

`04`	`import` `java.io.IOException;`

`05`	`import` `java.io.InputStreamReader;`

06

`07`	`public` `class` `Echo {`

08

`09`	`public` `static` `void` `main(String [] args)throws` `IOException{`

`10`	`String line;`

`11`	`InputStreamReader input =` `new` `InputStreamReader(System.in);`

`12`	`System.out.println("Enter data and push enter:");`

`13`	`BufferedReader reader =` `new` `BufferedReader(input);`

`14`	`line = reader.readLine();`

`15`	`System.out.println("Data entered :"+line);`

16 }

17

18 }

可以看出，这个类接受一个类型为inputStream的System.in对象，将之适配成Reader类型，然后再使用
BufferedReader类“装饰”它，将缓冲功能加上去。这样一来，就可以使用BufferedReader对象的readerLine()
方法读入整行的输入数据，数据类型是String。
在得到这个数据之后，程序又将它写出到System.out 中去，完成了全部的流操作，下图所示为其管道图：

本系统使用了BufferedReader来为流的读入提供缓冲功能，这样做的直接效果是可以使用readLine()方法按行读入数据。但是由于Reader接口并不提供readLine()方法，所以这样一来，系统就必须声明一个BufferedReader类型的流处理器，而不是一个Reader类型的流处理器，这意味着装饰模式的退化。
在上面的管道连接过程中，InputStreamReader 起到了适配器的作用，它将一个byte类型的输入流适配成为一个char类型的输入流。在这之后，BufferedReader则起到了装饰模式的作用，将缓冲机制引入到流的读入中。因此这个例子涉及到了两个设计模式。

poi读取excel

package com.scpii.ent.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import com.scpii.ent.mode.bean.DataSet;

public class ExcelOperClass {
private static String EXCEL_2003 = ".xls";
private static String EXCEL_2007 = ".xlsx";

public static void readExcelJXL() {

}

/**
* 通过POI方式读取Excel
*
* @param excelFile
*/
public static DataSet readExcelPOI(String filePath, Integer cons) throws Exception {
  File excelFile = new File(filePath);
  if (excelFile != null) {
   String fileName = excelFile.getName();
   fileName = fileName.toLowerCase();
   if (fileName.toLowerCase().endsWith(EXCEL_2003)) {
    DataSet dataSet = readExcelPOI2003(excelFile, cons);
    return dataSet;
   }
   if (fileName.toLowerCase().endsWith(EXCEL_2007)) {
    DataSet dataSet = readExcelPOI2007(excelFile, cons);
    return dataSet;
   }
  }
  return null;
}

/**
* 读取Excel2003的表单
*
* @param excelFile
* @return
* @throws Exception
*/
private static DataSet readExcelPOI2003(File excelFile, Integer rCons)
 throws Exception {
 List datasList = new ArrayList();
 Set colsSet = new HashSet();
 InputStream input = new FileInputStream(excelFile);
 HSSFWorkbook workBook = new HSSFWorkbook(input);
 // 获取Excel的sheet数量
 Integer sheetNum = workBook.getNumberOfSheets();
 // 循环Sheet表单
 for (int i = 0; i < sheetNum; i++) {
 HSSFSheet sheet = workBook.getSheetAt(i);
 if (sheet == null) {
 continue;
 }
 // 获取Sheet里面的Row数量
 Integer rowNum = sheet.getLastRowNum() + 1;
 for (int j = 0; j < rowNum; j++) {
 if (j>rCons) {
 System.out.println("===========");
 HSSFRow row = sheet.getRow(j);
 if (row == null) {
 continue;
 }

Integer cellNum = row.getLastCellNum() + 1;
 String[] datas = new String[cellNum];
 for (int k = 0; k < cellNum; k++) {
 HSSFCell cell = row.getCell(k);
 if (cell == null) {
 continue;
 }
 if (cell != null) {
 cell.setCellType(HSSFCell.CELL_TYPE_STRING);
 String cellValue = "";
 int cellValueType = cell.getCellType();
 if (cellValueType == cell.CELL_TYPE_STRING) {
 cellValue = cell.getStringCellValue();
 }
 if (cellValueType == cell.CELL_TYPE_NUMERIC) {
 Double number = cell.getNumericCellValue();

 System.out.println("字符串+++=========="+number.intValue());
 cellValue = cell.getNumericCellValue() + "";
 }

       if (rCons==k) {
        colsSet.add(cellValue);
       }

       System.out.println(cellValue);
       datas[k] = cellValue;
      }
     }
     datasList.add(datas);
    }
   }
  }
  DataSet dataSet = new DataSet(null, null, datasList, colsSet);
  return dataSet;
}

/**
* 读取Excel2007的表单
*
* @param excelFile
* @return
* @throws Exception
*/
private static DataSet readExcelPOI2007(File excelFile, Integer rCons) throws Exception {
 List datasList = new ArrayList();
 Set cosSet = new HashSet();
 InputStream input = new FileInputStream(excelFile);
 XSSFWorkbook workBook = new XSSFWorkbook(input);
 // 获取Sheet数量
 Integer sheetNum = workBook.getNumberOfSheets();
 for (int i = 0; i < sheetNum; i++) {
 XSSFSheet sheet = workBook.getSheetAt(i);
 if (sheet == null) {
 continue;
 }
 // 获取行值
 Integer rowNum = sheet.getLastRowNum() + 1;
 for (int j = 0; j < rowNum; j++) {
 if (j > rCons) {
 System.out.println("=============");
 XSSFRow row = sheet.getRow(j);
 if (row == null) {
 continue;
 }
 Integer cellNum = row.getLastCellNum() + 1;
 String[] datas = new String[cellNum];
 for (int k = 0; k < cellNum; k++) {
 XSSFCell cell = row.getCell(k);
 if (cell==null) {
 continue;
 }
 if (cell != null) {
 cell.setCellType(XSSFCell.CELL_TYPE_STRING);
 String cellValue = "";
 int cellValueType = cell.getCellType();
 if (cellValueType == cell.CELL_TYPE_STRING) {
 cellValue = cell.getStringCellValue();
 }
 if (cellValueType == cell.CELL_TYPE_NUMERIC) {
 Double number = cell.getNumericCellValue();
 System.out.println("字符串+++=========="+number.toString());
 cellValue = cell.getNumericCellValue() + "";
 }
 System.out.println(cellValue);
 if (rCons == k) {
 cosSet.add(cellValue);
 }
 datas[k] = cellValue;
 }
 }
 datasList.add(datas);
 }
 }
 }
 DataSet dataSet = new DataSet(null, null, datasList,cosSet);
 return dataSet;
}

public static void main(String[] args) {
// try {
// DataSet dataSet = readExcelPOI("D:\\部门员工资料.xls", 0);
// System.out.println("================================");
// Set datas = dataSet.getConStrctSet();
// String[] datastr = new String[datas.size()];
// datastr = datas.toArray(datastr);
// for (int i = 0; i < datastr.length; i++) {
// System.out.println(datastr[i]);
// }
// } catch (Exception e) {
// e.printStackTrace();
// }

 System.out.println(52%4);
}
}

package com.scpii.ent.mode.bean;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

public class DataSet {
private String[] headers;
private String[] rowHeaders;
private List datasList = new ArrayList();
private Set conStrctSet;

public DataSet(String[] headers, String[] rowHeaders,
   List datasList, Set conStrctSet) {
  this.headers = headers;
  this.rowHeaders = rowHeaders;
  this.datasList = datasList;
  this.conStrctSet = conStrctSet;
}

public DataSet(String[] header, String[] rowsHeader,
   List datasList2) {
  this.headers = header;
  this.rowHeaders = rowsHeader;
  this.datasList = datasList2;
}

public String[] getHeaders() {
return headers;
}

public void setHeaders(String[] headers) {
this.headers = headers;
}

public String[] getRowHeaders() {
return rowHeaders;
}

public void setRowHeaders(String[] rowHeaders) {
this.rowHeaders = rowHeaders;
}

public List getDatasList() {
return datasList;
}

public void setDatasList(List datasList) {
this.datasList = datasList;
}

public Set getConStrctSet() {
return conStrctSet;
}

public void setConStrctSet(Set conStrctSet) {
this.conStrctSet = conStrctSet;
}
}

java io 设计模式

http://my.oschina.net/gao0516/blog/136103

jquery对象和javascript的dom对象转换

Jquery框架为jquery对象定义了独立使用的方法和属性，它无法直接调用dom对象的方法，dom对象也无法直接调用jquery对象的方法和属性。

Jquery对象和dom对象是可以相互转换的，因为他们所操作的对象都是dom元素，只不过jquery对象包含了多个dom元素，而dom对象本身就是一个dom元素，简单地说，jquery对象是dom元素的数组，称为类数组，而dom对象就是单个的dom元素。

1.把jquery对象转换成dom对象

（1）借助数组下标来读取jquery对象集合中的某个dom元素对象。

Var $li = $(‘li’);//jquery对象

Var li = $li[0];//dom对象

（2）借助jquery对象的get()方法

Var $li = $(‘li’);//jquery对象

Var li = $li.get(0);//dom对象

2.dom对象转换为jquery对象

Var li = document.getElementsByTagName(‘div’);

Var $li = $(li[o]);//把第一个div元素封装为jquery对象

Var li = document.getElementsByTagName(‘div’);

Var $li = $(li);//把所以的div元素封装为jquery对象

Load事件必须等到网页中所以内容全部加载完毕后才执行。

当网页中内容很多时，load事件就会延迟

Jquery的ready事件是在dom结构绘制完毕后就执行，也就是说它在外部文件加载之前就执行了，ready事件先于load事件。

Load事件只能被编写一次，但是ready事件可以在同一个文档中多次定义。

wlecome

$(document).ready(function(){

$('').appendTo($('body'));

$('input[type="button"]')

.eq(0).click(function(){

$(this).val("红色").addClass('red'); }).end().eq(1).click(function(){

alert(1);

}).end().eq(2).click(function(){

alert(2);

}).end().eq(3).toggle(function(){

$('.panel').hide('slow');

},function(){

$('.panel').show('slow');

}

);

});

javascript创建新节点方法

        第二行


创建tbody中的内容
var tr = document.createElement('tr');
var ck_td = document.createElement('td');
var txt_td = document.createElement('td');
var ck = document.createElement('input');
var todo = document.createTextNode('第二行');
ck_td.setAttribute('width','20');
ck.setAttribute('type','checkbox');
ck_td.appendChild(ck);
txt_td.appendChild(todo);
tr.appendChild(ck_td);
tr.appendChild(txt_td);
document.getElementsByTagName('tbody')[0].appendChild(tr);

其他方法

tr.parentNode;//得到tr的父节点
       tr.removeChild(td);//删除tr节点的子节点td
       tr.nextElementSibling;//tr的下一个同级元素
           tr.nextSibling;//tr的下一个同级元素//

javascript面向对象中继承的几种方式

javascript模拟java中的StringBuffer连接字符串

javascript面向对象创建对象的五种方法

ajax下拉框联动

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

 My JSP 'car.jsp' starting page

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class CarServlet extends HttpServlet {


   /**
   *
   */
   private static final long serialVersionUID = 1L;

   public void doGet(HttpServletRequest request, HttpServletResponse response)
           throws ServletException, IOException {
       //DB取出数据
       Map> data = new HashMap>();
       List bmwList = new ArrayList();
       bmwList.add("521");
       bmwList.add("621");
       bmwList.add("721");
       bmwList.add("821");
       bmwList.add("X6");


       List audiList = new ArrayList();
       audiList.add("A1");
       audiList.add("A2");
       audiList.add("A3");
       audiList.add("A4");
       audiList.add("A5");
       audiList.add("A6");
       audiList.add("A8");

       List benzList = new ArrayList();
       benzList.add("B1");
       benzList.add("B2");
       benzList.add("B3");
       benzList.add("B4");
       benzList.add("B5");

       data.put("bmw", bmwList);
       data.put("audi", audiList);
       data.put("benz", benzList);
       //----------------------------------------------------------



       String name = request.getParameter("name");

       List dataList = data.get(name);


       response.setContentType("text/xml;charset=UTF-8");
       PrintWriter out = response.getWriter();

       out.print("");
       out.print("");
       for(String str : dataList) {
           out.print(""+str+"");
       }
       out.print("");

       out.flush();
       out.close();

   }

   public void doPost(HttpServletRequest request, HttpServletResponse response)
           throws ServletException, IOException {
       doGet( request, response);
   }

}

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AjaxServlet extends HttpServlet {

   private static final long serialVersionUID = 1L;

   @Override
   protected void service(HttpServletRequest request, HttpServletResponse response)
           throws ServletException, IOException {



       System.out.println("method:" + request.getMethod());
       String name = request.getParameter("name");
       System.out.println("Hello! " + name);

       response.setContentType("text/html");
       PrintWriter out = response.getWriter();
   /*   if("tom".equals(name)) {
           out.print("error");
       } else {
           out.print("ok");
       }*/

       out.print(name);
       out.flush();
       out.close();
   }

}

ajax笔记1

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>


 My JSP 'index.jsp' starting page

javascrip对象方法和数组方法

javascript闭包

jdbc的增删改查的方法

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcTest {

public static void main(String[] args) throws ClassNotFoundException,SQLException {

  //1.加载数据库驱动(提供一个jdbc的数据库驱动的名称)
  Class.forName("com.mysql.jdbc.Driver");

  //2.获取数据库连接
  String url = "jdbc:mysql:///gooddb";
  Connection conn = DriverManager.getConnection(url, "root", "root");

  //3.获取Statment对象(该对象用于对数据库进行CRUD操作)
  Statement stat = conn.createStatement();

  //4.执行SQL语句
  //String sql = "INSERT INTO t_class(classname) VALUES('java07')";
  String sql = "UPDATE t_class SET classname = 'sql01' WHERE id = 2";
  //executeUpdate()方法用于执行insert、update、delete语句，该方法返回影响数据库的行数
  int rows = stat.executeUpdate(sql);
  if(rows > 0) {
   System.out.println("操作成功！");
  }

  //5.释放连接
  stat.close();
  conn.close();


}
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class SelectTest {

public static void main(String[] args) {

  Connection conn = null;
  Statement stat = null;
  ResultSet rs = null;
  try {
   Class.forName("com.mysql.jdbc.Driver");

   conn = DriverManager.getConnection("jdbc:mysql:///gooddb","root","root");

   stat = conn.createStatement();

   String sql = "select id,classname from t_class";
   //获取结果集对象
   rs = stat.executeQuery(sql);

   while(rs.next()) {
    //int id = rs.getInt("id");
    int id = rs.getInt(1);
    //String name = rs.getString("classname");
    String name = rs.getString(2);

    System.out.println("id:" + id + "\tclassname:" + name);
   }
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  } catch (SQLException e) {
   e.printStackTrace();
  } finally {
   //释放连接
   try {
    if(rs != null) {
     rs.close();
    }
   } catch (SQLException e) {
    e.printStackTrace();
   } finally {
    try {
     if(stat != null) {
      stat.close();
     }

    } catch (SQLException e) {
     e.printStackTrace();
    } finally {
     try {
      if(conn != null) {
       conn.close();
      }
     } catch (SQLException e) {
      e.printStackTrace();
     }
    }
   }
  }


}
}

计算两个时间段相隔多少天的java方法

package com.tCalendar.d;

/*
* java.util.Calendar 类学习
*/

import java.text.SimpleDateFormat;

/**
*
* @author Icer
*/
public class TCalendar {

    private static SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyyMMdd");
    private String dayInfo[][];
    private int dayCount;//间隔天数

    public static void main(String[] args) {
        String startDate = "20120101";
        String endDate = "20120102";
        TCalendar tCalendar = new TCalendar();
        tCalendar.initDayInfo(startDate, endDate);
        System.out.println("天数: " + tCalendar.getDayCount());
    }

    public void initDayInfo(String start,String end)
    {
    //初始化日期信息
    java.util.Calendar cal1=java.util.Calendar.getInstance();
    java.util.Calendar cal2=java.util.Calendar.getInstance();
    java.util.Calendar cal3=java.util.Calendar.getInstance();
    int year,month,day;
    int i=0;
    year=Integer.parseInt(start.substring(0,4));
    month=Integer.parseInt(start.substring(4,6));
    day=Integer.parseInt(start.substring(6,8));
    cal1.set(year, month-1, day);
    cal3.set(year, month-1, day);
    year=Integer.parseInt(end.substring(0,4));
    month=Integer.parseInt(end.substring(4,6));
    day=Integer.parseInt(end.substring(6,8));
    cal2.set(year, month-1, day);
    while(!cal2.before(cal3))
    {
      i++;
      cal3.add(java.util.Calendar.DAY_OF_MONTH, 1);//日期时间+1
    }
    //每日数据列表
    dayInfo=new String[i+1][3];
    i=0;
    while(!cal2.before(cal1))
    {
                System.out.println("==" + cal1.getTime());
      dayInfo[i][0]=sDateFormat.format(cal1.getTime());
      i++;
      cal1.add(java.util.Calendar.DAY_OF_MONTH, 1);
    }

    this.dayCount=i;
    for (int j=0;j     {
      this.dayInfo[j][1]="0";
      this.dayInfo[j][2]="0";
    }

    }
    public int getDayCount() {
        return dayCount;
    }

    public void setDayCount(int dayCount) {
        this.dayCount = dayCount;
    }

    public String[][] getDayInfo() {
        return dayInfo;
    }

    public void setDayInfo(String[][] dayInfo) {
        this.dayInfo = dayInfo;
    }
}

java反射常用方法

package com.fanshe.obj;

import java.lang.reflect.*;
import java.io.IOException;
/**
*获取指定类的构造器相关信息
*/
public class ConstructorTest
{
private int i;
private double j;
//默认的构造器
public ConstructorTest(){
}
//重载的构造器
public ConstructorTest(int i,double j)throws IOException{
this.i=i;
this.j=j;
}
public static void main(String[] args) throws Exception
{
//得到本类的类对象
Class cls=Class.forName("com.fanshe.obj.ConstructorTest");
//取得所有在本类声明的构造器
Constructor []cs=cls.getDeclaredConstructors();
//遍历
System.out.println("----------------");
for(Constructor c:cs){
   //构造器名称
   System.out.println("构造器名="+c.getName());
   //构造器声明所在的类
   System.out.println("其声明的类="+c.getDeclaringClass());
   //取得参数的类型集合
   Class []ps=c.getParameterTypes();
   //遍历参数类型
   for(int i=0;i     System.out.println("参数类型"+i+"="+ps[i]);
   }
   //取得异常的类型集合
   Class []es=c.getExceptionTypes();
   //遍历异常类型
   for(int j=0;j     System.out.println("异常类型"+j+"="+es[j]);
   }
   //结束一层循环标志
   System.out.println("-----------");
}
}
}

package com.fanshe.obj;

import java.lang.reflect.*;
/**
*通过反射创新类的新对象
*/
class CreateNewObj
{
//显式默认的构造器
public CreateNewObj(){
}
//重载构造器
public CreateNewObj(int a,int b){
System.out.println("a= "+a+" b="+b);
}

public static void main(String[] args) throws Exception
{
//得到本类的类对象
Class c=Class.forName("com.fanshe.obj.CreateNewObj");
//声明构造器的参数类型集合
Class []paramTypes=new Class[2];
//都为int型
paramTypes[0]=Integer.TYPE;
paramTypes[1]=Integer.TYPE;
        //根据参数类型决定得到哪个构造器
Constructor cs=c.getConstructor(paramTypes);
//声明要传入的参数集合
Object []argList=new Object[2];
//传入37和43
argList[0]=new Integer(37);
argList[1]=new Integer(43);
//根据符合上述参数类型的构造器来创建新的对象
Object rtnObj=cs.newInstance(argList);
}
}

package com.fanshe.obj;

import java.lang.reflect.*;
/**
*获取指定类的字段相关信息
*/
class FieldTest
{
//字段1
private double d;
//字段2
public static final int i=37;
//字段3
String str="fieldstest";
public static void main(String[] args) throws Exception
{
//获取本类的类对象
Class c=Class.forName("com.fanshe.obj.FieldTest");
//获取所有声明的的字段,getFields()包括继承来的字段
Field []fs=c.getDeclaredFields();
//遍历
for(int i=0;i    Field f=fs[i];
   //字段名
   System.out.println("字段名"+(i+1)+"="+f.getName());
   //字段声明所在的类
   System.out.println("该字段所在的类为："+f.getDeclaringClass());
   //字段的类型
   System.out.println("字段"+(i+1)+"的类型："+f.getType());
   //查看修饰符
   int mod=f.getModifiers();
   //为0就是默认的包类型
   if(mod==0){
                System.out.println("该字段的修饰符为：默认包修饰符");
   }else{
    //否则就是相应的类型
    System.out.println("该字段的修饰符为："+Modifier.toString(mod));
   }
   System.out.println("---结束第"+(i+1)+"循环---");
}
}
}

package com.fanshe.obj;

import java.lang.reflect.*;
/**
*获取指定类的方法相关信息
*/
class InformationTest
{
public static void main(String[] args) throws Exception
{
//得到String类对象
Class cls=Class.forName("java.lang.String");
//得到所有的方法，包括从父类继承过来的方法
Method []methList=cls.getMethods();
//下面是得到的是String类本身声明的方法
//Method []methList=cls.getDeclaredMethods();
//遍历所有的方法
for(Method m:methList){
   //方法名
   System.out.println("方法名="+m.getName());
   //方法声明所在的类
   System.out.println("声明的类="+m.getDeclaringClass());
   //获取所有参数类型的集体
   Class []paramTypes=m.getParameterTypes();
   //遍历参数类型
   for(int i=0;i     System.out.println("参数 "+i+" = "+paramTypes[i]);
   }
   //获取所有异常的类型
   Class []excepTypes=m.getExceptionTypes();
   //遍历异常类型
   for(int j=0;j     System.out.println("异常 "+j+" = "+excepTypes[j]);
   }
   //方法的返回类型
   System.out.println("返回类型 ="+m.getReturnType());
   //结束一层循环标志
   System.out.println("---------");
}
}
}

package com.fanshe.obj;

import java.lang.reflect.*;
/**
*通过反射改变字段的值
*/
class ModifyField
{
//声明一个字段
public double d;
public static void main(String[] args) throws Exception
{
//得到类的类对象
Class c=Class.forName("com.fanshe.obj.ModifyField");
//根据字段名得到字段对象
Field f=c.getField("d");
//创建类的实例
ModifyField mf=new ModifyField();
//打印修改前字段的值
System.out.println("修改 "+f.getName()+" 前的值为："+mf.d);
//修改d的值为12.34
f.setDouble(mf,12.34);
//打印修改后的值
System.out.println("修改 "+f.getName()+" 后的值为："+mf.d);

}
}

package com.fanshe.obj;

import java.lang.reflect.*;
/**
*通过反射执行类的方法
*/
class PerformMethod
{
//声明一个简单的方法，用于测试
public int add(int a,int b){
return a+b;
}
public static void main(String[] args)throws Exception
{
//获取本类的类对象
Class c=Class.forName("com.fanshe.obj.PerformMethod");
/**
*声明add方法参数类型的集合
*共有两个参数，都为Integer.TYPE
*/
Class []paramTypes=new Class[2];
paramTypes[0]=Integer.TYPE;
paramTypes[1]=Integer.TYPE;
//根据方法名和参数类型集合得到方法
Method method=c.getMethod("add",paramTypes);
//声明类的实例
PerformMethod pm=new PerformMethod();
//传入参数的集合
Object []argList=new Object[2];
//传入37和43
argList[0]=new Integer(37);
argList[1]=new Integer(43);
//执行后的返回值
Object returnObj=method.invoke(pm,argList);
//类型转换下
Integer returnVal=(Integer)returnObj;
//打印结果
System.out.println("方法执行结果为："+returnVal.intValue());
}
}

package com.fanshe.obj;

import java.lang.reflect.*;
/**
*通过反射来操作数组
*/
class UserArray
{
public static void main(String[] args) throws Exception
{
//得到String类的类对象
Class c=Class.forName("java.lang.String");
//通过Array类的反射创建一个含有10个元素的String类型的数组
Object arr=Array.newInstance(c,10);
//为数组第5个位置元素赋一个值
Array.set(arr,5,"第5个位置元素");
//取得第5个位置元素的值
String s=(String)Array.get(arr,5);
//打印这个元素的值
System.out.println("值为："+s);
}
}

package com.fanshe.obj;

import java.lang.reflect.*;
/**
*通过反射创建和使用更复杂的数组
*/
class UserArrayComplex
{
public static void main(String[] args) throws Exception
{
//声明数组的维数为5X10X15
int dims[]=new int []{5,10,15};
//创建该类型的数组，元素的类型为Integer
Object arr=Array.newInstance(Integer.TYPE,dims);
//得到第3个10X15的二维数组
Object arrObj=Array.get(arr,3);
//Class c=arrObj.getClass().getComponentType();
//System.out.println(c);
//得到第2维中的第2个15位长度的数组
arrObj=Array.get(arrObj,5);
        //然后设置该数组里第10个元素的值为37
Array.set(arrObj,10,37);
//再将数组还原
int [][][]arrCast=(int [][][])arr;
//打印刚刚那个值
System.out.println(arrCast[3][5][10]);

}
}

设计模式之门面模式

门面模式是对象的结构模式，外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。
使用门面模式还有一个附带的好处，就是能够有选择性地暴露方法。一个模块中定义的方法可以分成两部分，一部分是给子系统外部使用的，一部分是子系统内部模块之间相互调用时使用的。有了Facade类，那么用于子系统内部模块之间相互调用的方法就不用暴露给子系统外部了。
public interface ServiceA {
void methodA() ;
}

public class ServiceAImpl implements ServiceA{

@Override
public void methodA() {
System.out.println("这是服务A");
}
}

public interface ServiceB {
void methodB() ;
}

public class ServiceBImpl implements ServiceB{

@Override
public void methodB() {
System.out.println("这是服务B");
}
}

public interface ServiceC {
void methodC() ;
}

public class ServiceCImpl implements ServiceC{

@Override
public void methodC() {
System.out.println("这是服务C");
}
}

public class Facade {
ServiceA sa;

     ServiceB sb;

     ServiceC sc;

     public Facade() {
         sa = new ServiceAImpl();
         sb = new ServiceBImpl();
         sc = new ServiceCImpl();
     }

     public void methodA() {
         sa.methodA();
         sb.methodB();
     }

     public void methodB() {
         sb.methodB();
         sc.methodC();
     }

     public void methodC() {
         sc.methodC();
         sa.methodA();
     }

}

测试类：

public class Test {
public static void main(String[] args) {
    ServiceA sa = new ServiceAImpl();
    ServiceB sb = new ServiceBImpl();
        sa.methodA();
        sb.methodB();
        System.out.println("========");
        //facade
        Facade facade = new Facade();
        facade.methodA();
        facade.methodB();
        facade.methodC();
    }

}

Struts2之annotation注解验证

                    input,back,cancel,browse
                    true

所以action中的这四个方法不需要验证

// 保存
   @Validations(
       requiredStrings = {
           @RequiredStringValidator(fieldName = "admin.username", message = "用户名不允许为空!"),
           @RequiredStringValidator(fieldName = "admin.password", message = "密码不允许为空!"),
           @RequiredStringValidator(fieldName = "admin.email", message = "E-mail不允许为空!")
       },
       requiredFields = {
           @RequiredFieldValidator(fieldName = "admin.isAccountEnabled", message = "是否启用不允许为空!")
       },
       stringLengthFields = {
           @StringLengthFieldValidator(fieldName = "admin.username", minLength = "2", maxLength = "20", message = "用户名长度必须在${minLength}到${maxLength}之间!"),
           @StringLengthFieldValidator(fieldName = "admin.password", minLength = "4", maxLength = "20", message = "密码长度必须在${minLength}到${maxLength}之间!")
       },
       emails = {
           @EmailValidator(fieldName = "admin.email", message = "E-mail格式错误!")
       },
       regexFields = {
           @RegexFieldValidator(fieldName = "admin.username", expression = "^[0-9a-z_A-Z\u4e00-\u9fa5]+$", message = "用户名只允许包含中文、英文、数字和下划线!")
       }
   )

$.cookie的用法

一个轻量级的cookie 插件，可以读取、写入、删除 cookie。

jquery.cookie.js 的配置

首先包含jQuery的库文件，在后面包含 jquery.cookie.js 的库文件。

使用方法

1.新添加一个会话 cookie：

$.cookie('the_cookie', 'the_value');

注：当没有指明 cookie有效时间时，所创建的cookie有效期默认到用户关闭浏览器为止，所以被称为

“会话cookie（session cookie）”。

2.创建一个cookie并设置有效时间为 7天:

$.cookie('the_cookie', 'the_value', { expires: 7 });

注：当指明了cookie有效时间时，所创建的cookie被称为“持久 cookie （persistent cookie）”。

3.创建一个cookie并设置 cookie的有效路径：

$.cookie('the_cookie', 'the_value', { expires: 7, path: '/' });

注：在默认情况下，只有设置 cookie的网页才能读取该 cookie。如果想让一个页面读取另一个页面设

置的cookie，必须设置cookie的路径。cookie的路径用于设置能够读取 cookie的顶级目录。将这

个路径设置为网站的根目录，可以让所有网页都能互相读取 cookie （一般不要这样设置，防止出现冲突）。

4.读取cookie：

$.cookie('the_cookie'); // cookie存在 => 'the_value'

$.cookie('not_existing'); // cookie不存在 => null

5.删除cookie，通过传递null作为cookie的值即可：

$.cookie('the_cookie', null);

----------相关参数的解释---------------

1).expires: 365

定义cookie的有效时间，值可以是一个数字（从创建cookie时算起，以天为单位）或一个Date 对

象。如果省略，那么创建的cookie是会话cookie，将在用户退出浏览器时被删除。

2).path: '/'

默认情况：只有设置cookie的网页才能读取该cookie。

定义cookie的有效路径。默认情况下，该参数的值为创建 cookie 的网页所在路径（标准浏览器的行为）。

如果你想在整个网站中访问这个cookie需要这样设置有效路径：path: '/'。如果你想删除一个定义

了有效路径的 cookie，你需要在调用函数时包含这个路径:$.cookie('the_cookie', null,

{ path: '/' });。 domain: 'example.com'

默认值：创建 cookie的网页所拥有的域名。

3).secure: true

默认值：false。如果为true，cookie的传输需要使用安全协议（HTTPS）。

4).raw: true

默认值：false。

默认情况下，读取和写入 cookie 的时候自动进行编码和解码（使用encodeURIComponent 编码，

decodeURIComponent 解码）。要关闭这个功能设置 raw: true 即可。

jdbc

public class DBHelp {

private static String driver;
private static String url;
private static String username;
private static String password;
private static BasicDataSource dataSource;

static{
 Properties properties = new Properties();

 try {
 //读取到src目录中存放的db.properties配置文件
 properties.load(DBHelp.class.getClassLoader().getResourceAsStream("db.properties"));
 driver = properties.getProperty("driver");
 url = properties.getProperty("url");
 username = properties.getProperty("username");
 password = properties.getProperty("password");
 } catch (IOException e) {
 e.printStackTrace();
 }


 dataSource = new BasicDataSource();

 dataSource.setDriverClassName(driver);
 dataSource.setUrl(url);
 dataSource.setUsername(username);
 dataSource.setPassword(password);
 dataSource.setInitialSize(5);
 dataSource.setMaxWait(5000);
 dataSource.setMaxActive(20);
 dataSource.setMinIdle(10);

}
public Connection getConnection(){
 try {
 Connection conn = dataSource.getConnection();

 return conn;
 } catch (SQLException e) {
 e.printStackTrace();
 }
 return null;
}
public List executeForList(RowMapper rowMapper,String sql) {
 Connection conn = null;
 PreparedStatement stat = null;
 ResultSet rs = null;
 List list = new ArrayList();

 try {
 conn = getConnection();
 stat = conn.prepareStatement(sql);
 rs = stat.executeQuery();
 while(rs.next()) {
 list.add(rowMapper.mapperRow(rs));
 }
 System.out.println("SQL"+sql);
 } catch (SQLException e) {
 e.printStackTrace();
 }finally{
 close(rs, stat, conn);
 }
 return list;
}

public List executeForList(String sql,RowMapper rowMapper,Object... args) {
 Connection conn = null;
 PreparedStatement stat = null;
 ResultSet rs = null;
 List list = new ArrayList();

 try {
 conn = getConnection();
 stat = conn.prepareStatement(sql);
 for (int i = 0; i < args.length; i++) {
 stat.setObject(i+1,args[i]);
 }
 rs = stat.executeQuery();
 while(rs.next()) {
 list.add(rowMapper.mapperRow(rs));
 }
 System.out.println("SQL"+sql);
 } catch (SQLException e) {
 e.printStackTrace();
 }finally{
 close(rs, stat, conn);
 }
 return list;
}

public T executeForObject(String sql,RowMapper rowMapper,Object... args) {
 Connection conn = null;
 PreparedStatement stat = null;
 ResultSet rs = null;
 T obj = null;

 try {
 conn = getConnection();
 stat = conn.prepareStatement(sql);
 for (int i = 0; i < args.length; i++) {
 stat.setObject(i+1, args[i]);
 }
 rs = stat.executeQuery();
 if(rs.next()) {
 obj = rowMapper.mapperRow(rs);
 }
 System.out.println("SQL"+sql);
 } catch (SQLException e) {
 e.printStackTrace();
 }finally{
 close(rs, stat, conn);
 }
 return obj;

}
public int executeForCount(String sql,Object... args){
 Connection conn = null;
 PreparedStatement stat = null;
 ResultSet rs = null;
 int count = 0;

 try {
 conn = getConnection();
 stat = conn.prepareStatement(sql);
 rs = stat.executeQuery();

 for(int i = 0;i < args.length;i++){
 stat.setObject(i+1, args[i]);
 }
 if(rs.next()) {
 count = rs.getInt(1);
 }
 System.out.println("SQL"+sql);
 } catch (SQLException e) {
 e.printStackTrace();
 }finally{
 close(rs, stat, conn);
 }
 return count;
}

public void executeUpdate(String sql,Object... args) {
 Connection conn = null;
 PreparedStatement stat = null;


 try {
 conn = getConnection();
 stat = conn.prepareStatement(sql);

 for(int i = 0;i < args.length;i++){
 stat.setObject(i+1, args[i]);
 }

 stat.executeUpdate();
 System.out.println("SQL"+sql);
 } catch (SQLException e) {
 e.printStackTrace();
 }finally{
 close(stat,conn);
 }

}

public void close(PreparedStatement stat,Connection conn) {
 close(null,stat,conn);
}
public void close(ResultSet rs,PreparedStatement stat,Connection conn) {
 try {
 if(rs != null){
 rs.close();
 }
 } catch (SQLException e) {
 e.printStackTrace();
 }finally{
 try {
 if(stat != null) {
 stat.close();
 }
 } catch (SQLException e) {
 e.printStackTrace();
 }finally{
 try {
 if(conn != null) {
 conn.close();
 }
 } catch (SQLException e) {
 e.printStackTrace();
 }
 }
 }
}

}

public interface RowMapper {
public T mapperRow(ResultSet rs) throws SQLException;
}

public class TourDao {
private DBHelp db = new DBHelp();
public Tour findByName(String name){
  String sql = "SELECT id,tourname FROM t_tour WHERE tourname=?";
  Tour t = db.executeForObject(sql, new TourRowMapper(), name);
  return t;
}
public void insertSale(String name){
  String sql = "INSERT INTO t_tour (tourname) VALUE(?)";
  db.executeUpdate(sql, name);
}
public class TourRowMapper implements RowMapper{

  public Tour mapperRow(ResultSet rs) throws SQLException {
   Tour t = new Tour();
   t.setId(rs.getInt("id"));
   t.setTourname(rs.getString("tourname"));

   return t;
  }

}
}

设计模式之备忘录模式

备忘录（Memento）模式又称标记（Token）模式。GOF给备忘录模式的定义为：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

其实单就实现保存一个对象在某一时刻的状态的功能，还是很简单的——将对象中要保存的属性放到一个专门管理备份的对象中，需要的时候则调用约定好的方法将备份的属性放回到原来的对象中去。

备忘录模式的组成部分：

　　1) 备忘录（Memento）角色：备忘录角色存储“备忘发起角色”的内部状态。“备忘发起角色”根据需要决定备忘录角色存储“备忘发起角色”的哪些内部状态。为了防止“备忘发起角色”以外的其他对象访问备忘录。备忘录实际上有两个接口，“备忘录管理者角色”只能看到备忘录提供的窄接口——对于备忘录角色中存放的属性是不可见的。“备忘发起角色”则能够看到一个宽接口——能够得到自己放入备忘录角色中属性。

　　2) 备忘发起（Originator）角色：“备忘发起角色”创建一个备忘录，用以记录当前时刻它的内部状态。在需要时使用备忘录恢复内部状态。

　　3) 备忘录管理者（Caretaker）角色：负责保存好备忘录。不能对备忘录的内容进行操作或检查。

使用备忘录模式的前提：

　　1) 必须保存一个对象在某一个时刻的(部分)状态, 这样以后需要时它才能恢复到先前的状态。

　　2) 如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。

例子如下：

//存储信息类
public class Caretaker {
private Memento memento;

    public Memento getMemento(){
        return this.memento;
    }

    public void setMemento(Memento memento){
        this.memento = memento;
    }

}

//备忘录模式
public class Memento {
   private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

}

public class Originator {
   private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public Memento createMemento() {
        return new Memento(state);
    }

    public void setMemento(Memento memento) {
        state = memento.getState();
    }

    public void showState(){
        System.out.println(state);
    }

}

测试类：

public class Test {
   public static void main(String[] args) {
        Originator org = new Originator();
        org.setState("开会中");
        org.showState();//显示
        System.out.println("---------------");
        Caretaker ctk = new Caretaker();

        ctk.setMemento(org.createMemento());//将数据封装在Caretaker
        System.out.println("---------------");
        org.setState("睡觉中");
        org.showState();//显示
        System.out.println("---------------");
        org.setMemento(ctk.getMemento());//将Caretaker中的数据重新导入
        org.showState();
        System.out.println("---------------");
    }

}

设计模式之中介者模式

Java深入到一定程度,就不可避免的碰到设计模式这一概念,了解设计模式,将使自己对java中的接口或抽象类应用有更深的理解.设计模式在java的中型系统中应用广泛,遵循一定的编程模式,才能使自己的代码便于理解,易于交流,Mediator(中介者模式)模式是比较常用的一个模式.

  Mediator中介者模式，当多个对象彼此间都有联系的时候，我们就可以应用Mediator将对象间的多对多关系转换为一对多的关系，这样做，可以使各个对象间的耦合松散。统一管理对象间的交互。但也可能使得Mediator对象成为一个系统中的庞然大物，难以维护
   使用场景:集中负责维护对象模型的关系完整性以及需要封装对象间交互方式的时候.
   其实MVC中的controller就是一种Mediator，是UI层和后端应用sevice层间的中介者。中介者将交互的复杂性变为中介者的复杂性

例子如下：
业务类的接口：

public interface Colleague {
void action();
}

业务类的2个实现类：

public class ColleagueA implements Colleague{

   @Override
   public void action() {
       System.out.println("普通员工努力工作aaaaaaa");
   }
}

public class ColleagueB implements Colleague{

   @Override
   public void action() {
       System.out.println("前台注意了bbbb");
   }
}

中介者接口：

public interface Mediator {
void notice(String content);
}

public class ConcreteMediator implements Mediator{
   private ColleagueA ca;

        private ColleagueB cb;

        public ConcreteMediator() {
            ca = new ColleagueA();
            cb = new ColleagueB();
        }

        public void notice(String content) {
            if (content.equals("boss")) {
                //老板来了, 通知员工A
                ca.action();
            }
            if (content.equals("client")) {
                //客户来了, 通知前台B
                cb.action();
            }
        }

}

测试类：

public class Test {
   public static void main(String[] args) {
            Mediator med = new ConcreteMediator();
            //老板来了
            med.notice("boss");

            //客户来了
            med.notice("client");
        }

}

当客户端传过来的字符串不一样时，中介者类根据字符串实现不同的业务类的对象，处理数据。

extjs 中判断坐标是否在选择区域中

function isInRect(x, y, x0, y0, x1, y1) {
if (x0 < x && x < x1 && y0 < y && y < y1)
return true;
else
return false;
}

extjs中触发隐藏和出现的方法

function ElIn(elId) {
var el = Ext.get(elId);
el.fadeIn( {
  endOpacity : 1,
  easing : 'easeOut',
  duration : 2
});
}

function ElOut(elId) {
var el = Ext.get(elId);
el.fadeOut( {
  endOpacity : 0,
  easing : 'easeOut',
  duration : .5,
  useDisplay : true
});
// el.dom.style.display = 'none';
}

extjs得到图片的坐标和让图片某一区域可以点击

function getClickScale(event, target, isShowInfo) {
var imageWidth = target.width;
var imageHeight = target.height;
var eventX = event.xy[0];
var eventY = event.xy[1];

var scalex = eventX / imageWidth;
var scaley = eventY / imageHeight;

var info = '';
info += 'image (' + imageWidth + ', ' + imageHeight + '), ';
info += 'click (' + eventX + ', ' + eventY + '), ';
info += 'scale (' + scalex + ', ' + scaley + ')';
if (typeof (isShowInfo) != 'undefined' && isShowInfo) {
alert(info);
}

return {
 scalex : scalex,
 scaley : scaley
};
}

Ext.get('main-navigator-image').on(
 'mousemove',
 function(event, target, obj) {
 var scale = getClickScale(event, target);
 target.style.cursor = '';
 for ( var i = 0; i < areas.length; i++) {
 var area = areas[i];
 if (isInRect(scale.scalex, scale.scaley,
 area.p1.scalex, area.p1.scaley,
 area.p2.scalex, area.p2.scaley)) {
 target.style.cursor = 'pointer';
 break;
 }
 }
 });
 });

访问tomcat时只输入ip就可以访问系统的方法

1.在tomcat的service.xml中把端口改成80
2.把自己的项目名称改成ROOT，覆盖tomcat的原ROOT项目，就可以了

extjs下拉框点击一行触发事件，得到valueField和displayField的值

Hibernate Fetch策略

hibernate抓取策略（单端代理的批量抓取）

保持默认，同fetch="select",如：

  fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

  设置fetch="join",如：

  fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合
  此时lazy会失效

hibernate抓取策略（集合代理的批量抓取）

  保持默认，同fetch="select",如：

  fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

  设置fetch="join",如：

  fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合此时lazy会失效

  设置fetch="subselect",如：

  fetch="subselect",另外发送一条select语句抓取在前面查询到的所有实体对象的关联集合

  hibernate抓取策略，,batch-size在上的应用
  batch-size属性，可以批量加载实体类，参见：Classes.hbm.xml


  hibernate抓取策略,batch-size在集合上的应用
  batch-size属性，可以批量加载实体类，参见：Classes.hbm.xml

  hibernate 会下先完发sql，再一次性的大数据

hibernate中实体类继承，按照子类建表

实体类父类：

public class Animal {

private int id;

private String name;

private boolean sex;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public boolean isSex() {
return sex;
}

public void setSex(boolean sex) {
this.sex = sex;
}
}

子类：

public class Bird extends Animal {

private int height;

public int getHeight() {
return height;
}

public void setHeight(int height) {
this.height = height;
}
}

public class Pig extends Animal {

private int weight;

public int getWeight() {
return weight;
}

public void setWeight(int weight) {
this.weight = weight;
}
}

extends.hbm.xml文件：

数据库表如下：

hibernate中实体类继承，分成若干表

父类实体类：

public class Animal {

private int id;

private String name;

private boolean sex;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public boolean isSex() {
return sex;
}

public void setSex(boolean sex) {
this.sex = sex;
}
}

子类实体类：

public class Bird extends Animal {

private int height;

public int getHeight() {
return height;
}

public void setHeight(int height) {
this.height = height;
}
}

public class Pig extends Animal {

private int weight;

public int getWeight() {
return weight;
}

public void setWeight(int weight) {
this.weight = weight;
}
}

extends.hbm.xml文件：

在数据库中表如下：

hibernate中每棵继承树映射成一张表

public class Animal {

private int id;

private String name;

private boolean sex;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public boolean isSex() {
return sex;
}

public void setSex(boolean sex) {
this.sex = sex;
}
}

public class Bird extends Animal {

private int height;

public int getHeight() {
return height;
}

public void setHeight(int height) {
this.height = height;
}
}

public class Pig extends Animal {

private int weight;

public int getWeight() {
return weight;
}

public void setWeight(int weight) {
this.weight = weight;
}
}

在extends.hbm.xml文件：

理解如何映射
因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
父类用普通的标签定义
在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
如：
子类使用标签定义，在定义subclass的时候，需要注意如下几点：
Subclass标签的name属性是子类的全路径名
在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）
的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标
签平行。当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值
是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

hibernate 中集合映射成表

实体类是：

public class CollectionMapping {

private int id;

private String name;

private Set setValue;

private List listValue;

private String[] arrayValue;

private Map mapValue;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Set getSetValue() {
return setValue;
}

public void setSetValue(Set setValue) {
this.setValue = setValue;
}

public List getListValue() {
return listValue;
}

public void setListValue(List listValue) {
this.listValue = listValue;
}

public String[] getArrayValue() {
return arrayValue;
}

public void setArrayValue(String[] arrayValue) {
this.arrayValue = arrayValue;
}

public Map getMapValue() {
return mapValue;
}

public void setMapValue(Map mapValue) {
this.mapValue = mapValue;
}
}

在CollectionMapping.hbm.xml文件中：

在数据库中生成5个表

hibernate中实体类中有其他普通类的引用，普通类的属性在数据库中是实体类的一个字段

例如：
普通类：

public class Contact {

private String email;

private String address;

private String zipCode;

private String contactTel;

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public String getAddress() {
return address;
}

public void setAddress(String address) {
this.address = address;
}

public String getZipCode() {
return zipCode;
}

public void setZipCode(String zipCode) {
this.zipCode = zipCode;
}

public String getContactTel() {
return contactTel;
}

public void setContactTel(String contactTel) {
this.contactTel = contactTel;
}
}

实体类：

public class User {

private int id;

private String name;

private Contact contact;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Contact getContact() {
return contact;
}

public void setContact(Contact contact) {
this.contact = contact;
}

}

User.hbm.xml文件：

在数据库中在t_user表中含有Contact类的属性字段

hibernate实体配置文件中主键生成策略

dom4j解析xml文件

1.先导入dom4j-1.6.1.jar包
2.xml文件如下：

  suc.jsp
  404.jsp

  book.jsp
  bookerror.jsp

  suc.jsp

3.解析测试类是：

package com.kaishengit.test;

import java.io.File;
import java.net.URL;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class Dom4jTest {

public void readXML() {
  //拿到src文件夹里的xml配置文件
  URL url = getClass().getResource("/");
  System.out.println(url);
  String filePath = url.getFile() + "struts.xml";

  try {
   //创建读取配置文件的对象
   SAXReader reader = new SAXReader();
   //开始读取配置文件
   Document doc = reader.read(new File(filePath));
   //拿到根节点
   Element root = doc.getRootElement();

   //拿到根节点下的action接点数组
   List actions = root.elements("action");

   for(Element action : actions) {
    String name = action.attributeValue("name");
    String className = action.attributeValue("className");
    String method = action.attributeValue("method");
    System.out.println("name="+name);
    System.out.println("className="+className);
    System.out.println("method="+method);

    List results = action.elements("result");
    for(Element result : results) {
     String resultName = result.attributeValue("name");
     String resultType = result.attributeValue("type");
     String pageName = result.getText();

     System.out.println("name:" + resultName + "\tresultType:" + resultType + "\tpageName:" + pageName);

    }

    System.out.println("----------------------");
   }


  } catch (Exception e) {
   e.printStackTrace();
  }

}

public static void main(String[] args) {


  Dom4jTest d = new Dom4jTest();
  d.readXML();



}
}

设计模式之状态模式

现在写一个用状态模式实现的根据上班时间状态变化而行为变化的小程序，当时间<12上午上班时间，
<13午休时间，<17下午上班时间，<21加班时间，根据时间不同，条用的类方法不同。
状态模式适用于当对象的状态改变时，行为也改变，就可以使用状态模式
状态接口：
public interface State {
void writeProgram(Work work);
}
不同的实现类：

public class AfterNoonState implements State {

@Override
public void writeProgram(Work work) {
 if(work.getHour()<17){
 System.out.println("工作");
 }else {
 work.setCurrent(new EveningState());
 work.writeProgram();
 }

}

public class EveningState implements State {

@Override
public void writeProgram(Work work) {
if(work.isFinish()){
 work.setCurrent(new RestState());
 work.writeProgram();
}else {
 if(work.getHour()<21){
 System.out.println("加班");
 }else {
 work.setCurrent(new SleepState());
 work.writeProgram();
 }
}

}

public class ForenoonState implements State {

@Override
public void writeProgram(Work work) {
if(work.getHour()<12){
System.out.println("工作时间");
}else {
work.setCurrent(new NoonState());
work.writeProgram();
}

}

}

public class NoonState implements State {

@Override
public void writeProgram(Work work) {
 if(work.getHour()<13){
 System.out.println("午睡");
 }else {
 work.setCurrent(new AfterNoonState());
 work.writeProgram();
 }

}

public class RestState implements State {

@Override
public void writeProgram(Work work) {
System.out.println("回家");

}

public class SleepState implements State {

@Override
public void writeProgram(Work work) {
System.out.println("睡觉");

}

调用状态的类：

public class Work {
private State current;

public Work(double hour,boolean finish){
current = new ForenoonState();
this.hour = hour;
this.finish = finish;
}
private double hour;
public double getHour() {
return hour;
}

public State getCurrent() {
return current;
}
public void setCurrent(State current) {
this.current = current;
}
private boolean finish;
public boolean isFinish() {
return finish;
}

public void writeProgram(){
current.writeProgram(this);
}
}

测试类：
public class Test {
public static void main(String[] args) {
Work work = new Work(20, true);
work.writeProgram();
}
}

mysql中查询值是空，是null的查询语句

这是表数据
SELECT * FROM t_user WHERE username IS NULL;查询到id=8的数据
SELECT * FROM t_user WHERE username IS NOT NULL;查询到id=11,12,13,14的四条数据
SELECT * FROM t_user WHERE username ='';查询到id=11,12,13的三条数据
SELECT * FROM t_user WHERE username ='aa';查询到id=14的数据

hibernate中的get方法和load方法的区别和使用

get和load方法都是是利用对象的主键得到对象，并可以使对象处于持久态。
load方法获取对象时不会立即执行查询操作，而是在第一次使用对象是再去执行查询操作。如果查询的对象在数据库中不存在，load方法返回值不会为null，在第一次使用时抛出org.hibernate.ObjectNotFoundException异常。
使用get方法获取对象时会立即执行查询操作，并且对象在数据库中不存在时返回null值。
所以我们在实际使用中多使用get方法，这样我们可以先判断得到的对象是否是null，再操作

spring对jdbc的支持SimpleJdbcTemplate

1.在配置文件中的配置：

    root
    root

2.dao中的写法：

package com.yjw.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
import com.yjw.bean.User;

public class UserSimpleJdbcTemplateDao {

private SimpleJdbcTemplate simpleJdbcTemplate;

public void setSimpleJdbcTemplate(SimpleJdbcTemplate simpleJdbcTemplate) {
  this.simpleJdbcTemplate = simpleJdbcTemplate;
}

public void save(User user){
  String sql = "INSERT INTO t_user (username,PASSWORD) VALUES (?,?)";
  simpleJdbcTemplate.update(sql, user.getUsername(),user.getPassword());
}
public void update(User user){
  String sql = "UPDATE t_user SET username=:username ,PASSWORD=:password WHERE id=:id?";

  simpleJdbcTemplate.update(sql, user.getUsername(),user.getPassword(),user.getId());
}
public void delete(int id){
  String sql = "delete from t_user where id=?";
  simpleJdbcTemplate.update(sql, id);
}
private class UserRowmapper implements RowMapper {

  public User mapRow(ResultSet rs, int rowNum) throws SQLException {
  User u = new User();
  u.setId(rs.getInt("id"));
  u.setUsername(rs.getString("username"));
  u.setPassword(rs.getString("password"));
   return u;
  }
}
public User getUser(int id) {
  String sql = "select id,username,password from t_user where id=?";
  User user = simpleJdbcTemplate.queryForObject(sql, new UserRowmapper(), id);
  return user;

}
public List getList(){
  String sql = "select id,username,password from t_user ";
  List list = simpleJdbcTemplate.query(sql, new UserRowmapper() );
  return list;
}
}

spring中aop 的配置实现

四种通知的执行地方：前置通知
try{
业务代码
后置通知
} catch{
异常通知
} finally{
最终通知
}
1.需要的jar包：aspectjrt.jar，aspectjweaver.jar，cglib-nodep-2.1.3.jar
2.在配置文件中加入

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p"
         xmlns:aop="http://www.springframework.org/schema/aop"
         xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd

package com.yjw.aspect;

public class MyXmlAspect {

//前置通知

public void beforeAdvice(){
System.out.println("前置通知");
}
//异常通知,接收异常信息

public void exceptionAdvice(Exception ex){
System.out.println("异常出现"+ex.getMessage());
}
//后置通知,可以接收方法的返回值

public void afterReturningAdvice(Object value){
System.out.println("后置通知"+value);
}
//最终通知

public void afterAdvice(){
System.out.println("after");
}
}

spring中aop的annotation的写法

package com.yjw.aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
//定义切面类，存放通知
@Aspect
public class MyAspect {

//切入点
/**第一个星号代表返回任何类型的数据，bean后的两个点代表本包及其子包，
* 第二个星号代表中间的所有的类；
* 第三个星号代表中间的所有的方法；
* (..)小括号代表参数列表，两个点代表参数类型不限
*/

@Pointcut("execution(* com.yjw.dao..*.*(..))")
public void pointCut(){}
//前置通知
@Before(" pointCut()")
public void beforeAdvice(){
  System.out.println("前置通知");
}
//异常通知,接收异常信息
@AfterThrowing( pointcut=" pointCut()",throwing="ex")
public void exceptionAdvice(Exception ex){
  System.out.println("异常出现"+ex.getMessage());
}
//后置通知,可以接收方法的返回值
@AfterReturning( pointcut=" pointCut()",returning="value")
public void afterReturningAdvice(Object value){
  System.out.println("后置通知"+value);
}
//最终通知
@After(" pointCut()")
public void afterAdvice(){
  System.out.println("zuizhong");
}

}

hibernate中使用原生sql语句查询集合和对象

查询集合
String sql = "select id, address,userid from t_address where userid in(select id from t_user where id in (select id from t_card where cardnum=112))";
SQLQuery query = session.createSQLQuery(sql).addEntity(Address.class);
List list = session.createSQLQuery(sql).list();
for(Object a : list){
Object[] address = (Object[]) a;
System.out.println(address[0]+" "+address[1]+" "+address[2]);
}
查询一个对象
String sql = "select id,username,password from t_user where id in (select id from t_card where cardnum=112)";
SQLQuery query = session.createSQLQuery(sql).addEntity(User.class);
User user = (User) query.uniqueResult();
System.out.println(user.getPwd());

设计模式之单例模式

单例就是在系统运行中只有一个实例对象

public class Factory {

   private static Factory factory = new Factory();
   private Factory(){
       System.out.println("--");
   }
   public static Factory getFactory(){
       return factory;

   }
   public void say(){
       System.out.println("say");
   }
}
第二种

public class Factory {

   private static Factory factory =null;
   private Factory(){
       System.out.println("--");
   }
   public synchronized static Factory getFactory(){
       if(factory==null){
           factory = new Factory();
       }
       return factory;

   }
   public void say(){
       System.out.println("say");
   }
}

设计模式之适配器模式

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

例子，让羊的叫声和狼一样，羊就是一个适配器：

public class Wolf {

   public void run() {
       System.out.println("wolf run");
   }

   public void ho() {
       System.out.println("wolf ho");
   }
}

适配器接口：

public interface Sheep {

public void run();
public void ho();
}

实现类：

public class SheepAdapter implements Sheep{

   private Wolf wolf;
   public SheepAdapter(Wolf wolf) {
       this.wolf = wolf;
   }

   @Override
   public void run() {
       wolf.run();
   }

   @Override
   public void ho() {
       wolf.ho();
   }

}

测试类：

    public static void main(String[] args) {

       Wolf w = new Wolf();
       Sheep sa = new SheepAdapter(w);
       sa.run();
       sa.ho();

   }
}

设计模式之装饰者模式

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

例子：
被装饰的接口：

public interface Cake {

public float cost();
}

接口的实现类：

public class MilkCake implements Cake{
   @Override
   public float cost() {
       return 100f;
   }
}

装饰者抽象类：

public abstract class CakeDecorator implements Cake{

}

装饰者的实现类

public class Chocolate extends CakeDecorator{

   private Cake cake;

   public Chocolate(Cake cake) {
       this.cake = cake;
   }

   @Override
   public float cost() {
       float chocolatePrice = 25f;
       return cake.cost() + chocolatePrice;
   }

}

public class Berry extends CakeDecorator {

   private Cake cake;
   public Berry(Cake cake) {
       this.cake = cake;
   }

   @Override
   public float cost() {
       float berryPrice = 5f;
       return cake.cost() + berryPrice;
   }
}

测试类：

public class Test {

   public static void main(String[] args) {

       MilkCake mc = new MilkCake();//牛奶蛋糕
       System.out.println(mc.cost());
       Berry b = new Berry(mc);//牛奶草莓蛋糕
       System.out.println(b.cost());
       Chocolate c = new Chocolate(b);//牛奶草莓巧克力蛋糕
       System.out.println("付款:" + c.cost());



   }
}

设计模式之外观模式

为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

1.当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。 Facade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过facade层。
2.客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。
3.当你需要构建一个层次结构的子系统时，使用facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系。
例子：
外观类：

public class Facade {
   ServiceA sa;

        ServiceB sb;

        ServiceC sc;

        public Facade() {
            sa = new ServiceAImpl();
            sb = new ServiceBImpl();
            sc = new ServiceCImpl();
        }

        public void methodA() {
            sa.methodA();
            sb.methodB();
        }

        public void methodB() {
            sb.methodB();
            sc.methodC();
        }

        public void methodC() {
            sc.methodC();
            sa.methodA();
        }

}

接口和接口的实现类：

public interface ServiceA {
void methodA() ;
}

public class ServiceAImpl implements ServiceA{

   @Override
   public void methodA() {
       System.out.println("这是服务A");
   }
}

public interface ServiceB {
void methodB() ;
}

public class ServiceBImpl implements ServiceB{

   @Override
   public void methodB() {
       System.out.println("这是服务B");
   }
}

public interface ServiceC {
void methodC() ;
}

public class ServiceCImpl implements ServiceC{

   @Override
   public void methodC() {
       System.out.println("这是服务C");
   }
}

测试类：

public class Test {
   public static void main(String[] args) {
       ServiceA sa = new ServiceAImpl();
       ServiceB sb = new ServiceBImpl();
        sa.methodA();
        sb.methodB();
        System.out.println("========");
        //facade
        Facade facade = new Facade();
        facade.methodA();
        facade.methodB();
        facade.methodC();
    }

}

设计模式之享元模式

运用共享技术有效地支持大量细粒度的对象。

1.一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
2.各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
3.控制子类扩展。
例子;
享元接口：

public interface Flyweight {
void action(int arg);

}

享元接口的实现类：

public class FlyweightImpl implements Flyweight{

   @Override
   public void action(int arg) {
          System.out.println("参数值: " + arg);
   }
}

产生精度对象的工厂类：

public class FlyweightFactory {
private static Map flyweightsMap = new HashMap();

    public FlyweightFactory(String arg) {
       System.out.println("-----------------");
        flyweightsMap.put(arg, new FlyweightImpl());
    }

    public static Flyweight getFlyweight(String key) {
        if (flyweightsMap.get(key) == null) {
            flyweightsMap.put(key, new FlyweightImpl());
        }
        return (Flyweight) flyweightsMap.get(key);
    }

    public static int getSize() {
        return flyweightsMap.size();
    }

}

测试类：

public class Test {
   public static void main(String[] args) {
        Flyweight fly1 = FlyweightFactory.getFlyweight("a");
        fly1.action(1);

        Flyweight fly2 = FlyweightFactory.getFlyweight("a");
        System.out.println(fly1 == fly2);

        Flyweight fly3 = FlyweightFactory.getFlyweight("c");
        fly3.action(3);

        Flyweight fly4 = FlyweightFactory.getFlyweight("d");
        fly4.action(4);

        Flyweight fly5 = FlyweightFactory.getFlyweight("e");
        fly5.action(5);

        System.out.println(FlyweightFactory.getSize());
    }

}

设计模式之代理模式

代理模式实现了类与类之间直接调用的解耦，例子：
代理模式主要使用了java的多态，干活的是被代理类，代理类主要的接活
，把活交给幕后的被代理类做，代理类和被代理类实现同一个接口。
被代理类的接口：

public interface Object {
void action();

}

被代理类的接口实现类：

public class ObjectImpl implements Object{
   public void action() {
            System.out.println("========");
            System.out.println("========");
            System.out.println("这是被代理的类");
            System.out.println("========");
            System.out.println("========");
        }

}

代理类：

public class ProxyObject implements Object{
   Object obj;

        public ProxyObject() {
            System.out.println("这是代理类");
            obj = new ObjectImpl();
        }

        public void action() {
            System.out.println("代理开始");
            obj.action();
            System.out.println("代理结束");
        }

}

测试类：

public class Test {
   public static void main(String[] args) {
       Object obj = new ProxyObject();
        obj.action();
   }
}

设计模式之策略模式

定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
适合场合：
* 1.以不同的格式保存文件
* 2.以不同的算法压缩文件
* 3.以不同的算法截取图形
* 4.以不同的格式输出数据的图形，曲线，框图等
策略接口：

public interface Strategy {
void method();

}

策略接口实现类：

public class StrategyImplA implements Strategy{
   public void method() {
        System.out.println("这是第一个实现a");
    }

}

public class StrategyImplB implements Strategy{
   public void method() {
        System.out.println("这是第二个实现b");
    }

}

public class StrategyImplC implements Strategy{
   public void method() {
            System.out.println("这是第三个实现c");
        }

}

调用类：

public class Context {
Strategy stra;

    public Context(Strategy stra) {
        this.stra = stra;
    }

    public void doMethod() {
        stra.method();
    }

}

测试：

public class Test {
   public static void main(String[] args) {
        Context ctx = new Context(new StrategyImplA());
        ctx.doMethod();

        ctx = new Context(new StrategyImplB());
        ctx.doMethod();

        ctx = new Context(new StrategyImplC());
        ctx.doMethod();
    }

}

设计模式之命令模式

命令模式就是将一组对象的相似行为，进行了抽象，将调用者与被调用者之间进行解耦，提
高了应用的灵活性。命令模式将调用的目标对象的一些异构性给封装起来，通过统一的方式来为调用者提供服务。

适用场景
    1、当一个应用程序调用者与多个目标对象之间存在调用关系时，并且目标对象之间的操作很类似的时候。
      2、例如当一个目标对象内部的方法调用太复杂，或者内部的方法需要协作才能完成对象的某个特点操作时。
      3、有时候调用者调用目标对象后，需要回调一些方法。
例子：
命令接口：

public interface Commond {

public void execute();
}

命令接口实现类：

public class LightOnCommond implements Commond{

   private Light light;
   public LightOnCommond(Light light) {
       this.light = light;
   }

   @Override
   public void execute() {
       light.on();
   }

}

命令的调用者：

public class Light {

   public void on() {
       System.out.println("灯亮了");
   }
}

public class TurnTvCommond implements Commond {

   private Tv tv;
   public TurnTvCommond(Tv tv) {
       this.tv = tv;
   }

   @Override
   public void execute() {
       tv.turn();

   }

}

public class Tv {

   public void turn() {
       System.out.println("调台");
   }
}

同时执行的多个命令数组

public class MracoCommond implements Commond{

   private Commond[] commonds;

   public MracoCommond(Commond...commonds) {
       this.commonds = commonds;
   }

   @Override
   public void execute() {
       for(Commond cmd : commonds) {
           cmd.execute();
       }
   }

}

命令的包装类，

public class RemoteContro {

   private List commondList = new ArrayList();

   public void setCommond(Commond commond) {
       commondList.add(commond);
   }

   public void buttonWasPressed(int index){
       commondList.get(index-1).execute();
   }
}

public class Test {

   public static void main(String[] args) {

       Light light = new Light();
       LightOnCommond loc = new LightOnCommond(light);
       Tv tv = new Tv();
       TurnTvCommond ttc = new TurnTvCommond(tv);
       MracoCommond mc = new MracoCommond(loc,ttc);
       RemoteContro rc = new RemoteContro();
       rc.setCommond(ttc);
       rc.setCommond(loc);
       rc.setCommond(mc);
       //rc.buttonWasPressed(3);
       //rc.buttonWasPressed(1);
       rc.buttonWasPressed(2);

   }
}

当输入123不同时，调用的命令不同，实现了多个命令的包装

spring中set注入

1.把依赖类(Service)和被依赖类(Dao)全部交给Spring管理
2.依赖类中提供被依赖类的set方法
3.在xml中进行配置
当把一个类交给spring管理是要给出一个无参数的构造方法给spring使用

spring初始化bean多例创建暨Bean的延迟加载开启方式

scope="prototype"是创建多例，不配置此项，默认单例
或者lazy-init值设置为true

spring使用静态工厂方法来实例化bean

public class Person1 implements Person{

private Person1(String s){
System.out.println(s);
}

public void say() {
  System.out.println("00000000000000");
}
public static Person1 getPerson1(){
  return new Person1("pppppppppp");

}
}

public class Test {

public static void main(String[] args) {
  ApplicationContext ctx =new ClassPathXmlApplicationContext("applicationContext.xml");
// UserService userservice =(UserService) ctx.getBean("person");
  /* User u = new User();
  u.setUsername("qq");
  u.setPassword("qq");
  userservice.save(u);*/
  Person person = (Person) ctx.getBean("person");
  person.say();

}

}

设计模式之观察者模式

概述：

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

适用性：

1.当一个抽象模型有两个方面,其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。 2.当对一个对象的改变需要同时改变其它对象,而不知道具体有多少对象有待改变。 3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁。

我们以天气预报的服务为例，安卓和诺基亚购买天气预报的服务，也可以停用服务：
天气预报主体的接口：

public interface Subject {

   public void zhuce(Observer observer);

   public void remove(Observer observer);

   public void tongzhi();
}

天气预报的实现类：

public class WeatherData implements Subject {

   private int low;
   private int hight;
   private String weather;
   private List list = new ArrayList();

   public void setData(int low, int hight, String weather) {
       this.low = low;
       this.hight = hight;
       this.weather = weather;
       tongzhi();
   }

   public int getLow() {
       return low;
   }

   public int getHight() {
       return hight;
   }

   public String getWeather() {
       return weather;
   }

   public void zhuce(Observer observer) {
       if (!list.contains(observer)) {
           list.add(observer);
       }

   }

   public void remove(Observer observer) {
       if (list.contains(observer)) {
           list.remove(observer);
       }

   }

   public void tongzhi() {
       for (Observer o : list) {
           o.update(getLow(), getHight(), getWeather());
       }

   }

}

观察者的接口：

public interface Observer {

void remove();

void update(int low, int hight, String weather);
}

观察者的实现类：

public class Android implements Observer {

   private Subject subject;

   public Android() {
   }

   public Android(Subject subject) {
       this.subject = subject;
       this.subject.zhuce(this);
   }

   public void update(int low, int hight, String weather) {
       System.out.println("android" + low + "" + hight + weather);

   }

   public void remove() {
       subject.remove(this);
   }
}

public class Nokia implements Observer{

   private Subject subject;
   public Nokia(){}
   public Nokia(Subject subject){
       this.subject = subject;
       this.subject.zhuce(this);
   }

   public void update(int low, int hight, String weather) {
       System.out.println("nokia:"+low+"-"+hight+"-"+weather);

   }

   public void remove(){
   subject.remove(this);
}
}

测试类：

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

       WeatherData wd = new WeatherData();
       wd.setData(1, 22, "晴朗");
       Android a = new Android(wd);
       wd.tongzhi();
       a.remove();
       Nokia n = new Nokia(wd);
       n.remove();
       wd.tongzhi();

   }
}

设计模式之状态模式

状态模式

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

用性：1.一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为。

    2.一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。
      这个状态通常用一个或多个枚举常量表示。
      通常,有多个操作包含这一相同的条件结构。
      State模式将每一个条件分支放入一个独立的类中。
      这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。

状态模式在工作流或游戏等各种系统中有大量使用，甚至是这些系统的核心功能设计，例如
政府OA中，一个批文的状态有多种：未办；正在办理；正在批示；正在审核；已经完成等
各种状态，使用状态机可以封装这个状态的变化规则，从而达到扩充状态时，不必涉及到状
态的使用者。

在网络游戏中，一个游戏活动存在开始；开玩；正在玩；输赢等各种状态，使用状态模式就
可以实现游戏状态的总控，而游戏状态决定了游戏的各个方面，使用状态模式可以对整个游
戏架构功能实现起到决定的主导作用。

状态模式实质：
使用状态模式前，客户端外界需要介入改变状态，而状态改变的实现是琐碎或复杂的。

使用状态模式后，客户端外界可以直接使用事件Event实现，根本不必关心该事件导致如
何状态变化，这些是由状态机等内部实现。

这是一种Event-condition-State，状态模式封装了condition-State部分。

每个状态形成一个子类，每个状态只关心它的下一个可能状态，从而无形中形成了状态转换
的规则。如果新的状态加入，只涉及它的前一个状态修改和定义。

状态转换有几个方法实现：一个在每个状态实现next()，指定下一个状态；还有一种方法，
设定一个StateOwner，在StateOwner设定stateEnter状态进入和stateExit状
态退出行为。

状态从一个方面说明了流程，流程是随时间而改变，状态是截取流程某个时间片。

例子：
操作当前状态类：

public class Context {
   private Weather weather;

        public void setWeather(Weather weather) {
            this.weather = weather;
        }

        public Weather getWeather() {
            return this.weather;
        }

        public String weatherMessage() {
            return weather.getWeather();
        }

}

状态接口：

public interface Weather {
String getWeather();

}

状态实现类：

public class Sunshine implements Weather{
   public String getWeather() {
        return "阳光";
    }

}

public class Rain implements Weather{
   public String getWeather() {
            return "下雨";
        }

}

测试类：

public class Test {
   public static void main(String[] args) {
        Context ctx1 = new Context();
        ctx1.setWeather(new Sunshine());
        System.out.println(ctx1.weatherMessage());

        System.out.println("===============");

        ctx1.setWeather(new Rain());
        System.out.println(ctx1.weatherMessage());
    }

}

例子2：

public class Work {
private State current;

   public Work(double hour,boolean finish){
   current = new ForenoonState();
   this.hour = hour;
   this.finish = finish;
}
private double hour;
public double getHour() {
   return hour;
}

public State getCurrent() {
   return current;
}
public void setCurrent(State current) {
   this.current = current;
}
private boolean finish;
public boolean isFinish() {
   return finish;
}

public void writeProgram(){
   current.writeProgram(this);
}
}

public interface State {
void writeProgram(Work work);
}

public class ForenoonState implements State {

 @Override
 public void writeProgram(Work work) {
 if(work.getHour()<12){
 System.out.println("工作时间");
 }else {
 work.setCurrent(new NoonState());
 work.writeProgram();
 }

 }

}

public class NoonState implements State {

 @Override
 public void writeProgram(Work work) {
 if(work.getHour()<13){
 System.out.println("午睡");
 }else {
 work.setCurrent(new AfterNoonState());
 work.writeProgram();
 }

 }

}

public class AfterNoonState implements State {

 @Override
 public void writeProgram(Work work) {
 if(work.getHour()<17){
 System.out.println("工作");
 }else {
 work.setCurrent(new EveningState());
 work.writeProgram();
 }

 }

}

public class EveningState implements State {

 @Override
 public void writeProgram(Work work) {
 if(work.isFinish()){
 work.setCurrent(new RestState());
 work.writeProgram();
 }else {
 if(work.getHour()<21){
 System.out.println("加班");
 }else {
 work.setCurrent(new SleepState());
 work.writeProgram();
 }
 }

 }

}

public class SleepState implements State {

   @Override
   public void writeProgram(Work work) {
       System.out.println("睡觉");

   }

}

设计模式之访问者模式

访问者模式主要是将很多操作都在一个接口中声明，在接口的实现类中都要实现这些操作，
在具体的访问者类中规定了需要调用实现类的哪个方法，
例子如下：
访问者接口：

public interface Visitor {
public void visitString(StringElement stringE);

    public void visitFloat(FloatElement floatE);

    public void visitCollection(Collection collection);
    public void visitInt(IntElement inte);

}

访问者接口实现类

public class ConcreteVisitor implements Visitor{
   public void visitCollection(Collection collection) {
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            Object o = iterator.next();
            if (o instanceof Visitable) {
                ((Visitable)o).accept(this);
            }
        }
    }

    public void visitFloat(FloatElement floatE) {
        System.out.println(floatE.getFe());
    }

    public void visitString(StringElement stringE) {
        System.out.println(stringE.getSe());
    }

   @Override
   public void visitInt(IntElement inte) {
       System.out.println(inte.getInts());

   }

}

操作类的接口：

public interface Visitable {
public void accept(Visitor visitor);

}

操作类的具体实现类：

public class FloatElement implements Visitable{
private Float fe;

    public FloatElement(Float fe) {
        this.fe = fe;
    }

    public Float getFe() {
        return this.fe;
    }

    public void accept(Visitor visitor) {
        visitor.visitFloat(this);
    }

}

public class IntElement implements Visitable{
   private int ints;

   public int getInts() {
       return ints;
   }

   public IntElement(int i){
       this.ints = i;
   }

   @Override
   public void accept(Visitor visitor) {
       visitor.visitInt(this);

   }

}

public class StringElement implements Visitable{
private String se;

    public StringElement(String se) {
        this.se = se;
    }

    public String getSe() {
        return this.se;
    }

    public void accept(Visitor visitor) {
        visitor.visitString(this);
    }

}

测试类：

public class Test {
   public static void main(String[] args) {
        Visitor visitor = new ConcreteVisitor();
        Visitable se = new StringElement("abc");
        se.accept(visitor);

        Visitable fe = new FloatElement(new Float(1.5));
        fe.accept(visitor);
        System.out.println("===========");
        List result = new ArrayList();
        result.add(new StringElement("abc"));
        result.add(new StringElement("abc"));
        result.add(new StringElement("abc"));
        result.add(new FloatElement(new Float(1.5)));
        result.add(new FloatElement(new Float(1.5)));
        result.add(new FloatElement(new Float(1.5)));
        visitor.visitCollection(result);
        Visitable is = new IntElement(2);
        is.accept(visitor);
    }

}

设计模式之模板模式

概述：

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

适用性：

1.一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

    2.各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。
      首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。
      最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
例子如下：模板类：

public abstract class Template {
   public abstract void print();

        public void update() {
            System.out.println("公共的代码");
           System.out.println("下面是子类各自实现的代码");
                print();

        }
}

模板类的子类：

public class TemplateConcrete extends Template{
      @Override
        public void print() {
            System.out.println("这是子类的实现");
        }

}

测试类

public class Test {
   public static void main(String[] args) {
        Template temp = new TemplateConcrete();
        temp.update();
    }

}

extjs中为表格添加单选行单元格的事件

grid.addListener('cellclick', cellclick);
function cellclick(grid, rowIndex, columnIndex, e) {
  var record = grid.getStore().getAt(rowIndex);
  var fieldName = grid.getColumnModel().getDataIndex(columnIndex);
  var data = record.get(fieldName);
  if(data==null){ //处理预览
   var alias=record.get("Alias");
   window.open(url);
   //window.location.href="DoIpcammera?dowith=preview&&alias="+alias;
  }
}

extjs自动生成排序数组

new Ext.grid.RowNumberer()

extjs中单选Radio的使用

设计模式之职责链模式

职责链模式规定了一个请求，这个请求需要特定的对象去处理，当把这个请求交个一个对象，但是这个对象不负责处理这个请求，可以动态地交给其他对象处理，直到交给对的对象处理，这些对象都有处理请求的机会，只有当请求是该自己负责的时候才处理，否则交给其他对象。

下面以==============

要离职, 人事审批!

请求完毕

===========

要加薪, 项目经理审批!

========

要请假, 项目组长审批!

的规定，写一个职责链模式的例子：

这是所有请求的接口

public interface Request {

void getRequest();

}

请假的请求实现类

public class LeaveRequest implements Request{

@Override

public void getRequest() {

System.out.println("leave");

}

离职的请求实现类

public class DimissionRequest implements Request{

@Override

public void getRequest() {

System.out.println("dimission");

}

加薪的请求实现类

public class AddMoneyRequest implements Request{

@Override

public void getRequest() {

System.out.println("add money");

}

处理请求的接口

public interface RequestHandle {

void handleRequest(Request request);

}

Hr处理离职的请求

public class HRRequestHandle implements RequestHandle{

public void handleRequest(Request request) {

if (request instanceof DimissionRequest) {

System.out.println("要离职, 人事审批!");

}

System.out.println("请求完毕");

}

组长处理请假的请求

public class TLRequestHandle implements RequestHandle{

RequestHandle rh;

public TLRequestHandle(RequestHandle rh) {

this.rh = rh;

}

public void handleRequest(Request request) {

if (request instanceof LeaveRequest) {

System.out.println("要请假, 项目组长审批!");

} else {

rh.handleRequest(request);

}

经理处理加薪的请求

public class PMRequestHandle implements RequestHandle{

RequestHandle rh;

public PMRequestHandle(RequestHandle rh) {

this.rh = rh;

}

public void handleRequest(Request request) {

if (request instanceof AddMoneyRequest) {

System.out.println("要加薪, 项目经理审批!");

} else {

rh.handleRequest(request);

}

测试类

public class Test {

public static void main(String[] args) {

//先把所有的处理请求的对象组成职责链

RequestHandle hr = new HRRequestHandle();

RequestHandle tl = new TLRequestHandle(hr);//组长

RequestHandle pm = new PMRequestHandle(tl);//经理

Request dimissionRequest = new DimissionRequest();

Request addMoneyRequest = new AddMoneyRequest();

Request leaveRequest = new LeaveRequest();

System.out.println("==============");

//人事处理离职请求

pm.handleRequest(dimissionRequest);

System.out.println("===========");

//经理处理加薪请求

pm.handleRequest(addMoneyRequest);

System.out.println("========");

//项目组长处理请假请求

pm.handleRequest(leaveRequest);

}

在使用时要调用最高级的职责调用者，由他去负责往下分配职责

mysql中is null和=null的含义

is null是判断某个字段是否是空，为空并不等价于空字符串或者数字0
=null 是判断某个值是否等于null，null=null，和null<>null都是false

mysql查询去除重复数据DISTINCT

select DISTINCT job from emp where deptno=20

mysql函数中upper（）的意思和排除空值

select name from user where upper(name) ='TOM' and sal is not null;
upper()函数的作用是把表中的name转换成大写再做比较

mysql求数值列的和，其中一列可能是空

求薪金sal列和绩效comm列的和，comm可能是空，
select sal+if(comm is null,0,comm) from emp;
当comm是空时，返回0，不空时返回comm的数值

struts2中用ognl访问普通类的构造方法

public class User implements Serializable{

/**
*
*/
private static final long serialVersionUID = 1L;

private String name;
public User(){
System.out.println("===============");
}
public User(String name){
this.name = name;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return "user="+this.name;
}

}

struts2用ognl访问普通类的静态属性和静态方法

public class Test {

public static String NAME = "nametom";
public static String test(){
return "testtom";
}
}

在struts.xml配置文件中加

struts2中ognl直接访问action中的方法

public class UserAction extends ActionSupport{

/**
*
*/
private static final long serialVersionUID = 1L;
  public String mm(){
  return "mm";

}
}

struts2中ognl在视图中访问对象的方法

public class User implements Serializable{

/**
*
*/
private static final long serialVersionUID = 1L;

private String name;
public User(){
System.out.println("===============");
}
public User(String name){
this.name = name;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return "user="+this.name;
}

}

public class UserAction extends ActionSupport{

/**
*
*/
private static final long serialVersionUID = 1L;
private String name;
private User user;
private Cat cat;

@Override
public String execute() throws Exception {
// System.out.println(cat.getFriend().getName());
  return ActionSupport.SUCCESS;

}
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}
public User getUser() {
  return user;
}
public void setUser(User user) {
  this.user = user;
}
public Cat getCat() {
  return cat;
}
public void setCat(Cat cat) {
  this.cat = cat;
}

}

struts2控制反转时创建对象一定要有参数是空的实体类的构造方法

public class User implements Serializable{

/**
*
*/
private static final long serialVersionUID = 1L;

private String name;
public User(){
System.out.println("========空的构造方法=必须有======");
}
public User(String name){
this.name = name;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

}

public class UserAction extends ActionSupport{

/**
*
*/
private static final long serialVersionUID = 1L;
private String name;
private User user;

@Override
public String execute() throws Exception {
  System.out.println(user.getName());
  return ActionSupport.SUCCESS;

}
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}
public User getUser() {
  return user;
}
public void setUser(User user) {
  this.user = user;
}

}

struts2验证框架的使用

验证框架的命名规则是Action类名字-action的bean名字-validation.xml，这个验证文件需要放在需要验证的.class文件同一目录下
例如UserAction-tologin-validation.xml

       "-//Apache Struts//XWork Validator 1.0.2//EN"
       "http://struts.apache.org/dtds/xwork-validator-1.0.2.dtd">

                   10
                   20
                   必须是整数

name必须填写

在struts-xml中的配置

               /WEB-INF/user/list.jsp
               /WEB-INF/user/user.jsp

struts2一个表单多种提交ognl

               /WEB-INF/user/list.jsp


public class UserAction extends ActionSupport{

   private static final long serialVersionUID = 1L;

   private User user;
   private String id;

   @Override
   public String execute() throws Exception {

       return ActionSupport.SUCCESS;
   }

   public String login(){

       return ActionSupport.SUCCESS;
   }

   public String print(){
       System.out.println(user.getName());
       System.out.println(user.getPassword());
       System.out.println(id);
       return ActionSupport.SUCCESS;
   }


   public User getUser() {
       return user;
   }

   public void setUser(User user) {
       this.user = user;
   }

   public String getId() {
       return id;
   }

   public void setId(String id) {
       this.id = id;
   }


}

struts2重定向到jsp传值

重定向传参数


   /index2.jsp?t=${name}

public class UserAction extends ActionSupport{

/**
*
*/
private static final long serialVersionUID = 1L;
private String name;
@Override
public String execute() throws Exception {
  System.out.println(name);
  return ActionSupport.SUCCESS;

}
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}

}

struts2中四种实现request，session，application的方法

第一种
public class UserAction extends ActionSupport{

/**
*
*/
private static final long serialVersionUID = 1L;
private String name;
private Map session;
private Map request;
private Map application;
@Override
public String execute() throws Exception {
  session = ActionContext.getContext().getSession();
  request = (Map) ActionContext.getContext().get("request");
  application = ActionContext.getContext().getApplication();
  session.put("sk", "sv");
  request.put("rk", "rv");
  application.put("ak", "av");
  System.out.println(name);
  return ActionSupport.SUCCESS;

}
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}

}

第二种

public class DepAction extends ActionSupport implements RequestAware,SessionAware,ApplicationAware{

private Map request;
private Map session;
private Map application;

public void setRequest(Map request) {
this.request = request;

}

public void setSession(Map session) {
this.session = session;

}

public void setApplication(Map application) {
this.application = application;

}

}

第三种

public class CarAction implements ServletRequestAware{
private HttpServletRequest request;
private HttpSession session;
private ServletContext application;

public void setServletRequest(HttpServletRequest request) {
  this.request = request;
  this.session = request.getSession();
  this.application = session.getServletContext();

}

}

第四种

public class HomeAction extends ActionSupport{

private HttpServletRequest request;
private HttpSession session;
private ServletContext application;

public HomeAction (){
  request = ServletActionContext.getRequest();
  session = request.getSession();
  application = session.getServletContext();
}

}

struts2的标签ognl

摘要: Struts2常用标签总结一介绍 1．Struts2的作用 Struts2标签库提供了主题、模板支持，极大地简化了视图页面的编写，而且，struts2的主题、模板都提供了很好的扩展性。实现了更好的代码复用。Struts2允许在页面中使用自定义组件，这完全能满足项目中页面显示复杂，多变的需求。 Struts2的标签库有一个巨大的改进之处，struts2标签库的标签不依赖于任何... 阅读全文

struts2值栈取值和session，request，application的取值

在strut2中所以的值都在值栈中存放，在页面中加入标签，就可以点击显示出当前值栈中的所有值，如图
可以通过标签得到值栈中的值，value的值是PropertyName,就可以得到对应的value

在action中session，request，application都是Map数据类型的
private Map session;
private Map request;
private Map application;
session = ActionContext.getContext().getSession();
  request = (Map) ActionContext.getContext().get("request");
  application = ActionContext.getContext().getApplication();
  session.put("sk", "sv");
  request.put("rk", "rv");
  application.put("ak", "av");
想在页面中取到相应的值；

使用观看他们都是存放在栈区，#+名称就可以取到值

struts2命名空间和访问路径

namespace决定来了action的访问路径，当namespace=“”时，可以接受所有路径的action，namespace=“/”,

或者"/xxx,或者"/xxx/yyy",对应的action访问路径是/index.action,或者/xxx/index.action,或

者/xxx/yyy/index.action.

<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort

()+path+"/";
%>

在使用namespace时容易出现路径问题，在会出现路径问题的jsp页面中加上base标签，就不会了。

java取得实时上周的时间

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Test {
   public static void main(String[] args) {
       Calendar calendar = Calendar.getInstance();
       calendar.setFirstDayOfWeek(Calendar.MONDAY);

       calendar.add(Calendar.DATE, -7);
       calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
       Date   sTime = calendar.getTime();
       calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
       Date   eTime = calendar.getTime();
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
       String s = sdf.format(sTime) + " 00:00:00";
       String e = sdf.format(eTime) + " 23:59:59";
       System.out.println(s);
       System.out.println(e);
   }
}

struts2实现登录拦截器和验证方法

摘要: 在struts2中的拦截器的定义是先定义一个类实现Interceptor接口，重写intercept方法。下面是实现登录验证的拦截器。

java复习

Typeof（）返回值有6中可能：number，string，boolean，object，function，undefined

Prompt(“请输入名称”)返回字符

eval(“”)可以把“”中的字符串执行

在java中继承的构造方法的规则：

1. 子类的构造的过程中必须调用其父类的构造方法。

2. 子类可以在自己的构造方法中使用super（argument—list）调用父类的构造方法。

3. 使用this（argument—list）调用自己的另外的构造方法。

4. 如果调用super，必须卸载子类构造方法的第一行。

5. 如果子类的构造方法中没有显示调用父类工作服，系统默认调用父类无参数的构造方法。

6. 如果子类构造方法中没有显示调用父类的构造方法，而父类中又没有无参数的构造方法，编译出错。

哈希编码：每个对象都有一个独一无二的哈希编码，通过这个哈希编码可以找到这个对象。

多态中动态绑定规则;1.有继承，2.有重写（子类重写父类中的方法），3.父类引用指向子类对象。

Public void getId(final int i){}表示i在此方法中不同被修改

hibernate对数据库的建立和删除

java io读取文本文件

public class ReadSql {

public static void readsql(String filePath) throws Exception{
  String encoding = "gbk";
  File file = new File(filePath);
  if(file.isFile()&&file.exists()){
   InputStreamReader reader = new InputStreamReader(new FileInputStream(file),encoding);
  BufferedReader bufferedReader = new BufferedReader(reader);
   String line = null;
   while ((line = bufferedReader.readLine())!=null) {
     System.out.println(line.toString());
   }
   reader.close();
  }
}
public static void main(String[] args) throws Exception {
  System.out.println("=================================================");
  ReadSql.readsql("c:/rr.txt");

  System.out.println("=================================================");
}
}

阿里云注册用户建立自己的网站

阿里云服务平台注册相当于申请到了一台服务器主机，想运行java web项目很简单，安装jdk，tomcat，数据库，把编译好的项目放在tomcat中，启动tomcat，在外网直接访问阿里云主机ip和端口，项目名称，就可以了

java网络编程中tcp和udp

在网络编程中，先启动service，再启动clent。
1.tcp
服务端

public class Service {

public static void main(String[] args) throws Exception {

ServerSocket ss = new ServerSocket(6666);

System.out.println("等待");

while (true) {

Socket socket =ss.accept();

InputStream is = socket.getInputStream();

DataInputStream dataInputStream = new DataInputStream(is);

System.out.println(dataInputStream.readUTF());

dataInputStream.close();

socket.close();

}

}
客户端

public class CientSocket {

public static void main(String[] args) throws Exception {

Socket socket = new Socket("127.0.0.1",6666);

OutputStream outputStream = socket.getOutputStream();

DataOutputStream dataOutputStream = new DataOutputStream(outputStream);

dataOutputStream.writeUTF("333333333");

dataOutputStream.flush();

dataOutputStream.close();

socket.close();

}

udp通信，是不区分客户端和服务端的

public class Service {

public static void main(String[] args) throws Exception {

byte buf[] = new byte[1024];

DatagramPacket dPacket = new DatagramPacket(buf, buf.length);

DatagramSocket dSocket = new DatagramSocket(5678);

while (true) {

dSocket.receive(dPacket);

System.out.println(new String(buf,0,dPacket.getLength()));

}

public class UdpClient {

public static void main(String[] args) throws Exception{

while (true) {

byte[] buf = (new String("hello")).getBytes();

DatagramPacket dpPacket = new DatagramPacket(buf, buf.length, new InetSocketAddress("127.0.0.1", 5678));

//自己占用9999端口

DatagramSocket dSocket = new DatagramSocket(9999);

dSocket.send(dpPacket);

dSocket.close();

}

web.xml加载过程

当我们去启动一个 WEB 项目的时候, 容器(包括 JBoss, Tomcat 等)首先会去读项目的 web.xml 配置文件里面的信息,

当这一步骤没有出错并且完成之后, 项目才能正常的被启动起来。

1> 首先是, 容器会先读节点, 并创建一个 ServletContext 实例, 以节点的 name 作为键, value 作为值,

存储到上下文环境中。

2> 接着, 容器会去读节点, 根据配置的 class 类路径来创建监听。

3> 接着, 容器去读节点, 根据指定的类路径来实例化过滤器。

以上都是在 WEB 项目还没有完全启动起来的时候就已经完成了的工作。如果系统中有用到 Servlet, 则 Servlet 是在第一次发起请求的时候被实例化的,

且一般不会被容器销毁, 它可以服务于多个用户的请求。所以, Servlet 的初始化都要比上面提到的那几个要迟。

总的来说, web.xml 的加载顺序是: context-param --> listener --> filter --> servlet

其中, 如果 web.xml 中出现了相同的节点, 则是按照在配置文件中出现的先后顺序来加载的。

下面引入一个小列子来说明:

net.yeah.fancydeepin.listener.AppStartListener

technology

java,javascript,ajax,css,html

ReDespatcherFilter

net.yeah.fancydeepin.filter.ReDespatcherFilter

android, python, c

ReDespatcherFilter

ReDespatcherFilter2

net.yeah.fancydeepin.filter.ReDespatcherFilter2

mail

[email protected]

package net.yeah.fancydeepin.listener;

import java.util.Arrays;
import java.util.List;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class AppStartListener implements ServletContextListener{

    public void contextInitialized(ServletContextEvent contextEvent) {
        System.out.println("********************************************");
        ServletContext context = contextEvent.getServletContext();
        List params = Arrays.asList(context.getInitParameter("technology").split(","));
        for(String param : params){
            System.out.print(param + "\t");
        }
        System.out.println("\n********************************************");
    }

    public void contextDestroyed(ServletContextEvent contextEvent) {

    }

}

package net.yeah.fancydeepin.filter;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class ReDespatcherFilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {

        System.out.println("============================================");
        System.out.println(filterConfig.getInitParameter("it"));
        System.out.println("============================================");
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,ServletException{

        chain.doFilter(request, response);
    }

    public void destroy() {

    }
}

package net.yeah.fancydeepin.filter;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class ReDespatcherFilter2 implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {

        System.out.println("++++++++++++++++++++++++++++++++++++++++++++");
        System.out.println(filterConfig.getInitParameter("mail"));
        System.out.println("++++++++++++++++++++++++++++++++++++++++++++");
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,ServletException{

        chain.doFilter(request, response);
    }

    public void destroy() {

    }
}

后台启动输出结果:

Context上下文的区别

在 java 中, 常见的 Context 有很多,

像: ServletContext, ActionContext, ServletActionContext, ApplicationContext, PageContext, SessionContext ...

那么, Context 究竟是什么东西呢? 直译是上下文、环境的意思。比如像: "今天我收到了一束花, 男朋友送的!" 又或者 "今天我收到了一束花, 送花的人送错了的!"

同样是收到一束花, 在不同的上下文环境中表达的意义是不一样的。

同样的, Context 其实也是一样, 它离不开所在的上下文环境, 否则就是断章取义了。

另外, 在网络上也有些人把 Context 看成是一些公用信息或者把它看做是一个容器的, 个人觉得这种解释稍好。

接下来说说 ServletContext, ActionContext, ServletActionContext。

1> ServletContext

一个 WEB 运用程序只有一个 ServletContext 实例, 它是在容器(包括 JBoss, Tomcat 等)完全启动 WEB 项目之前被创建, 生命周期伴随整个 WEB 运用。

当在编写一个 Servlet 类的时候, 首先是要去继承一个抽象类 HttpServlet, 然后可以直接通过 getServletContext() 方法来获得 ServletContext 对象。

这是因为 HttpServlet 类中实现了 ServletConfig 接口, 而 ServletConfig 接口中维护了一个 ServletContext 的对象的引用。

利用 ServletContext 能够获得 WEB 运用的配置信息, 实现在多个 Servlet 之间共享数据等。

eg:

url

jdbc:oracle:thin:@localhost:1521:ORC

username

scott

password

tigger

ConnectionServlet

net.yeah.fancydeepin.servlet.ConnectionServlet

ConnectionServlet

/ConnectionServlet.action

PrepareConnectionServlet

net.yeah.fancydeepin.servlet.PrepareConnectionServlet

PrepareConnectionServlet

/PrepareConnectionServlet.action

package net.yeah.fancydeepin.servlet;

import java.io.IOException;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class PrepareConnectionServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    public void init() throws ServletException {

        ServletContext context = getServletContext();
        String url = context.getInitParameter("url");
        String username = context.getInitParameter("username");
        String password = context.getInitParameter("password");
        context.setAttribute("url", url);
        context.setAttribute("username", username);
        context.setAttribute("password", password);
    }

    protected void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{

        doPost(request, response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        response.sendRedirect("ConnectionServlet.action");
    }
}

package net.yeah.fancydeepin.servlet;

import java.io.IOException;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;

public class ConnectionServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

        ServletContext context = getServletContext();
        System.out.println("***************************************");
        System.out.println("URL: " + context.getAttribute("url"));
        System.out.println("Username: " + context.getAttribute("username"));
        System.out.println("Password: " + context.getAttribute("password"));
        System.out.println("***************************************");
        super.service(request, response);
    }
}

当访问 PrepareConnectionServlet.action 时, 后台打印输出:

***********************************************
URL: jdbc:oracle:thin:@localhost:1521:ORC
Username: scott
Password:  tigger
***********************************************

2> ActionContext

ActionContext 是当前 Action 执行时的上下文环境, ActionContext 中维护了一些与当前 Action 相关的对象的引用,

如: Parameters (参数), Session (会话), ValueStack (值栈), Locale (本地化信息) 等。

在 Struts1 时期, Struts1 的 Action 与 Servlet API 和 JSP 技术的耦合度都很紧密, 属于一个侵入式框架:

public ActionForward execute(ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response){
    // TODO Auto-generated method stub
    return null;
}

到了 Struts2 时期, Struts2 的体系结构与 Struts1 之间存在很大的不同。Struts2 在 Struts1 的基础上与 WebWork 进行了整合, 成为了一个全新的框架。

在 Struts2 里面, 则是通过 WebWork 来将与 Servlet 相关的数据信息转换成了与 Servlet API 无关的对象, 即 ActionContext 对象。

这样就使得了业务逻辑控制器能够与 Servlet API 分离开来。另外, 由于 Struts2 的 Action 是每一次用户请求都产生一个新的实例, 因此,

ActionContext 不存在线程安全问题, 可以放心使用。

package net.yeah.fancydeepin.action;

import java.util.Map;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.util.ValueStack;

public class ContextAction extends ActionSupport {

    private static final long serialVersionUID = 1L;
    private String username;
    private String password;

    public String execute(){

        ActionContext context = ActionContext.getContext();
        ValueStack value = context.getValueStack();
        value.set("username", username);
        value.set("password", password);
        Map session = context.getSession();
        session.put("url", "http://www.blogjava.net/fancydeepin");
        return SUCCESS;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

当访问 context.action 并传给相应的参数的时候, 在浏览器中会输出相应的信息。

留意到上面 Struts2 的 Action 中并有没添加属性的 getting 方法, 而是手动的将参数值放到值栈(ValueStack)中的, 否则页面是得不到参数来输出的。

3> ServletActionContext

首先, ServletActionContext 是 ActionContext 的一个子类。ServletActionContext 从名字上来看, 意味着它与 Servlet API 紧密耦合。

ServletActionContext 的构造子是私有的, 主要是提供了一些静态的方法, 可以用来获取: ActionContext, ActionMapping, PageContext,

HttpServletRequest, HttpServletResponse, ServletContext, ValueStack, HttpSession 对象的引用。

public String execute(){

    //或 implements ServletRequestAware
    HttpServletRequest request = ServletActionContext.getRequest();
    //或 implements ServletResponseAware
    HttpServletResponse response = ServletActionContext.getResponse();
    //或 implements SessionAware
    HttpSession session = request.getSession();
    //或 implements ServletContextAware
    ServletContext context = ServletActionContext.getServletContext();

    return SUCCESS;
}

java递归阶乘

public static int method(int n){

if(n==1){

return 1;

}else {

return n*method(n-1);

}

public static long fab(int i){

if(i==1||i==2){

return 1;

}else {

return fab(i-1)+fab(i-2);

}

把编译好的web工程用cmd打成war包或者jar包

1.先把编辑好的web文件放在c盘下，比如项目名是hello
2.打开cmd，进入hello中，c:\hello>
3.输入jar cvf hello.war . ,就可以在hello文件夹中找到hello.war
输入jar -cvf hello.jar *.*;

DATE_FORMAT函数的用法

DATE_FORMAT() 函数用于以不同的格式显示日期/时间数据。

语法是

DATE_FORMAT(date,format)

date 参数是合法的日期。 format 规定日期/时间的输出格式。

下面的脚本使用 DATE_FORMAT() 函数来显示不同的格式。我们使用 NOW() 来获得当前的日期/时间：

DATE_FORMAT(NOW(),'%b %d %Y %h:%i %p') DATE_FORMAT(NOW(),'%m-%d-%Y') DATE_FORMAT(NOW(),'%d %b %y') DATE_FORMAT(NOW(),'%d %b %Y %T:%f')

结果类似：

Dec 29 2008 11:45 PM 12-29-2008 29 Dec 08 29 Dec 2008 16:25:46.635

当数据库中有个字段time，数据格式是

2013-03-25 14:35:20

按年查询：

DATE_FORMAT(timetext,'%Y')=‘2013’
按年排序

DATE_FORMAT(timetext,'%Y')

按月查询

DATE_FORMAT(timetext,'%m')='03
'

java.util.ConcurrentModificationException

这个问题是说,你不能在对一个List进行遍历的时候将其中的元素删除掉
解决办法是,你可以先将要删除的元素用另一个list装起来,等遍历结束再remove掉
可以这样写
List delList = new ArrayList();//用来装需要删除的元素
for(Information ia:list)
if(ia.getId()==k){
n++;
delList.add(ia);
}
list.removeAll(delList);//遍历完成后执行删除

随机产生4位和6位数字字符串

package com.test;

/**
* 动态生成随机字符数组
*
*
*/
public class ShortMessageCodeUntil
{

 /**
 * 随机生成4位数字字符数组
 *
 * @return rands
 */
 public static char[] generateCheckCode()
 {
 String chars = "0123456789";
 char[] rands = new char[4];
 for (int i = 0; i < 4; i++)
 {
 int rand = (int) (Math.random() * 10);
 rands[i] = chars.charAt(rand);
 }
 return rands;
 }

 /**
 * 随机生成6位数字字符数组
 *
 * @return rands
 */
 public static char[] generateCheckPass()
 {
 String chars = "0123456789";
 char[] rands = new char[6];
 for (int i = 0; i < 6; i++)
 {
 int rand = (int) (Math.random() * 10);
 rands[i] = chars.charAt(rand);
 }
 return rands;
 }
public static void main(String[] args) {
 ShortMessageCodeUntil sm = new ShortMessageCodeUntil();
 System.out.println(sm.generateCheckCode());
 System.out.println(sm.generateCheckPass());
}

}

得的html中a标签中的值

点击

建造者模式

Builder模式定义: 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.
Builder模式是一步一步创建一个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们.
用户不知道内部的具体构建细节.Builder模式是非常类似抽象工厂模式,细微的区别大概只有在反复使用中才能体会到.
为何使用? 是为了将构建复杂对象的过程和它的部件解耦.注意: 是解耦过程和部件.
因为一个复杂的对象,不但有很多大量组成部分,如汽车,有很多部件:车轮方向盘发动机还有各种小零件等等,
部件很多,但远不止这些,如何将这些部件装配成一辆汽车,这个装配过程也很复杂(需要很好的组装技术),Builder模式就是为了将部件和组装过程分开.
如何使用? 首先假设一个复杂对象是由多个部件组成的,Builder模式是把复杂对象的创建和部件的创建分别开来,分别用Builder类和Director类来表示.
首先,需要一个接口,它定义如何创建复杂对象的各个部件:
public interface Builder {
//创建部件A 比如创建汽车车轮
void buildPartA();
//创建部件B 比如创建汽车方向盘
void buildPartB();
//创建部件C 比如创建汽车发动机
void buildPartC();
//返回最后组装成品结果 (返回最后装配好的汽车)
//成品的组装过程不在这里进行,而是转移到下面的Director类中进行. //从而实现了解耦过程和部件
Product getResult();
}
用Director构建最后的复杂对象,而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的),也就是说Director的内容是如何将部件最后组装成成品:
public class Director {
private Builder builder;
public Director( Builder builder ) {
this.builder = builder;
} // 将部件partA partB partC最后组成复杂对象 //这里是将车轮方向盘和发动机组装成汽车的过程
public void construct() {
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
}
}
Builder的具体实现ConcreteBuilder: 通过具体完成接口Builder来构建或装配产品的部件;
定义并明确它所要创建的是什么具体东西; 提供一个可以重新获取产品的接口:
public class ConcreteBuilder implements Builder {
Part partA, partB, partC; public void buildPartA() {
//这里是具体如何构建partA的代码 };
public void buildPartB() {
//这里是具体如何构建partB的代码 };
public void buildPartC() {
//这里是具体如何构建partB的代码 };
public Product getResult() { //返回最后组装成品结果 };
复杂对象:产品Product:
public interface Product { }
复杂对象的部件:
public interface Part { }
我们看看如何调用Builder模式:
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );
director.construct();
Product product = builder.getResult();

}

Builder模式的应用在Java实际使用中,我们经常用到"池"(Pool)的概念,当资源提供者无法提供足够的资源,并且这些资源需要被很多用户反复共享时,就需要使用池.
"池"实际是一段内存,当池中有一些复杂的资源的"断肢"(比如数据库的连接池,也许有时一个连接会中断),如果循环再利用这些"断肢",将提高内存使用效率,提高池的性能.修改Builder模式中Director类使之能诊断"断肢"断在哪个部件上,再修复这个部件.

单例模式

单态定义: Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
在很多操作中，比如建立目录数据库连接都需要这样的单线程操作。
还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。
另外方面，Singleton也能够被无状态化。提供工具性质的功能， Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？ //注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private Singleton(){}
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次 //使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance;
}
}
使用Singleton.getInstance()可以访问单态类。
上面第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。
注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton
实例。
一般认为第一种形式要更加安全些。

设计模式之工厂模式

工厂模式定义:提供创建对象的接口
为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。
我们以类Sample为例，如果我们要创建Sample的实例对象:
Sample sample=new Sample();
可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值查询数据库等。
首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:
Sample sample=new Sample(参数);
但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。
为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java面向对象的原则，面向对象的封装(Encapsulation)
和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。
在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。
这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:
Sample mysample=new MySample(); Sample hissample=new HisSample();
随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.
但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
工厂方法你会建立一个专门生产Sample实例的工厂:
public class Factory{
public static Sample creator(int which){
//getClass 产生Sample 一般可使用动态类装载装入类。 if (which==1) return new SampleA(); else if (which==2)
return new SampleB();
}
}
那么在你的程序中,如果要实例化Sample时.就使用
Sample sampleA=Factory.creator(1);
这样,在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会
使用工厂方法要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample，
进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类concreteFactory了。
抽象工厂工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory).
这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.
这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类Sample2A和SampleB2
那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){ ......... return new SampleA }
public Sample2 creator(String name){ ......... return new Sample2A }
}
public class BombFactory extends Factory{
public Sample creator(){ ...... return new SampleB }
public Sample2 creator(String name){ ...... return new Sample2B }
}
从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2?
抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。

jquery选项卡

时事

体育

娱乐

时事

jquery控制字体大小

       放大
       缩小

       This is some text. This is some text. This is some text. This is some text. This
       is some text. This is some text. This is some text. This is some text. This is some
       text. This is some text. This is some text. This is some text. This is some text.
       This is some text. This is some text. This is some text. This is some text. This
       is some text. This is some text.

jquery表格内容过滤

筛选：

姓名	性别	暂住地
张山	男	浙江宁波
李四	女	浙江杭州
王五	男	湖南长沙
找六	男	浙江温州
Rain	男	浙江杭州
MAXMAN	女	浙江杭州
王六	男	浙江杭州
李字	女	浙江杭州
李四	男	湖南长沙

jquery的表格伸缩显示隐藏

姓名	性别	暂住地
前台设计组
张山	男	浙江宁波
李四	女	浙江杭州
前台开发组
王五	男	湖南长沙
找六	男	浙江温州
后台开发组
Rain	男	浙江杭州
MAXMAN	女	浙江杭州

jquery的表格的隔行换色和多选行

姓名	性别	暂住地
张山	男	浙江宁波
李四	女	浙江杭州
王五	男	湖南长沙
找六	男	浙江温州
Rain	男	浙江杭州
MAXMAN	女	浙江杭州

姓名	性别	暂住地
张山	男	浙江宁波
李四	女	浙江杭州
王五	男	湖南长沙
找六	男	浙江温州
Rain	男	浙江杭州
MAXMAN	女	浙江杭州

jquery的表格的隔行换色和单选某行

姓名	性别	暂住地
张山	男	浙江宁波
李四	女	浙江杭州
王五	男	湖南长沙
找六	男	浙江温州
Rain	男	浙江杭州
MAXMAN	女	浙江杭州

jquery表单，邮箱的验证

下拉框左右选择，得到值

           选中添加到右边>>
           全部添加到右边>>

<<选中删除到左边
 <<全部删除到左边
 <<选中的所有值

文件的下载

               File f = new File("c://a.txt");
                   BufferedInputStream bis =new BufferedInputStream(new FileInputStream(f));
                   byte[] buffer = new byte[1024];
                   response.setContentType("application/octet-stream");
                   //定义下载文件的名字
                   String a = new String(z.getZiname().getBytes("utf-8"),"iso8859-1");

                   response.setHeader("Content-Disposition", "attachment; filename=\"" + a+"c://a.txt".substring("c://a.txt".lastIndexOf(".")) + "\"");
                    OutputStream os = response.getOutputStream();
                   int len = -1;
                   while((len=bis.read(buffer))!=-1){
                       os.write(buffer, 0, len);
                   }
                   os.flush();
                   os.close();
                   bis.close();

复选框的全选

复选框按钮

复选框

jquery文本框得到失去焦点

jxl导出excel表格

先要导入jxl需要的jar包，然后在触发导出excel时传入集合对象，例如：

public class ToExcel {

 public static void excel(List l,HttpServletResponse response) {
 ServletOutputStream out = null;
 WritableWorkbook wwb = null;
 try {
 // 导出Excel路径
 Date d = new Date();
 String s = new SimpleDateFormat("yyyyMMddHHmmss").format(d);

 response.setCharacterEncoding("utf-8");
 response.reset();
 response.setContentType("application/vnd.ms-excel;charset=utf-8");
 response.setHeader("Content-Disposition", "attachment;filename="
 + new String("历史数据.xls".getBytes(),"iso-8859-1"));
 out = response.getOutputStream();

 WritableSheet ws = null;
 wwb = Workbook.createWorkbook(out);
 ws = wwb.createSheet("sheet1", 0);
 // 文字样式
 WritableFont wf = new WritableFont(WritableFont.TIMES, 10,
 WritableFont.BOLD, false);
 WritableCellFormat wcff = new WritableCellFormat(wf);
 // 标题
 // 第一列第1行(0,0)
 Label label1 = new Label(0, 0, "编号", wcff);
 // 第一列第2行(0,1)
 Label label2 = new Label(1, 0, "环境温度", wcff);
 // 第一列第3行(0,2)
 Label label3 = new Label(2, 0, "环境湿度", wcff);
 Label label4 = new Label(3, 0, "光照强度", wcff);
 Label label5 = new Label(4, 0, "土壤温度", wcff);
 Label label6 = new Label(5, 0, "土壤湿度", wcff);
 Label label7 = new Label(6, 0, "co2浓度", wcff);
 // 第一列第4行(0,3)
 Label label8 = new Label(7, 0, "时间", wcff);
 // 第一列第5行(0,4)
 Label label9 = new Label(8, 0, "星期几", wcff);
 ws.addCell(label1);
 ws.addCell(label2);
 ws.addCell(label3);
 ws.addCell(label4);
 ws.addCell(label5);
 ws.addCell(label6);
 ws.addCell(label7);
 ws.addCell(label8);
 ws.addCell(label9);
 for (int i = 0; i < l.size(); i++) {
 Label l1 = new Label(0, i + 1, l.get(i).getStr("node"));
 Label l2 = new Label(1, i + 1, l.get(i).getStr("wen"));
 Label l3 = new Label(2, i + 1, l.get(i).getStr("shi"));
 Label l4 = new Label(3, i + 1, l.get(i).getStr("sun"));
 Label l5 = new Label(4, i + 1, l.get(i).getStr("tuwen"));
 Label l6 = new Label(5, i + 1, l.get(i).getStr("tushi"));
 Label l7 = new Label(6, i + 1, l.get(i).getStr("co"));
 Label l8 = new Label(7, i + 1, l.get(i)
 .getTimestamp("timetext").toString());
 Label l9 = new Label(8, i + 1, l.get(i).getStr("week"));
 ws.addCell(l1);
 ws.addCell(l2);
 ws.addCell(l3);
 ws.addCell(l4);
 ws.addCell(l5);
 ws.addCell(l6);
 ws.addCell(l7);
 ws.addCell(l8);
 ws.addCell(l9);
 }
 wwb.write();
 } catch (Exception e) {
 e.printStackTrace();
 }finally{

 try {
 wwb.close();
 } catch (WriteException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 } catch (IOException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }


 }
 }

}

javascript的事件方法

onblur 事件发生在窗口失去焦点的时候。应用于：window 对象
onchange 事件发生在文本输入区的内容被更改，然后焦点从文本输入区
移走之后。捕捉此事件主要用于实时检测输入的有效性，或者立刻改变文
档内容。应用于：P assword 对象；S elect 对象；T ext 对象；T extarea 对
象
onclick 事件发生在对象被单击的时候。单击是指鼠标停留在对象上，
按下鼠标键，没有移动鼠标而放开鼠标键这一个完整的过程。一个普通按
钮对象（Button）通常会有 onclick 事件处理程序，因为这种对象根本
不能从用户那里得到任何信息，没有 onclick 事件处理程序就等于废柴。
按钮上添加 onclick 事件处理程序，可以模拟“另一个提交按钮”，方
法是：在事件处理程序中更改表单的 action, target, encoding, method
等一个或几个属性，然后调用表单的 submit() 方法。在 Link 对象的
onclick 事件处理程序中返回 false 值（return false），能阻止浏览
器打开此连接。即，如果有一个这样的连接：< a href="http://www.a.com"
οnclick="return false">Go!，那么无论用户怎样点击，都不会去到
www.a.com 网站，除非用户禁止浏览器运行 JavaScript。应用于：B utton
对象；Checkbox 对象；Image 对象；Link 对象；Radio 对象；Reset 对
象；Submit 对象
onerror 事件发生在错误发生的时候。它的事件处理程序通常就叫做
“错误处理程序”(Error Handler)，用来处理错误。上边已经介绍过，
要忽略一切错误，就使用：
function ignoreError() {
return true;
}
window.onerror = ignoreError;
应用于：window 对象
onfocus 事件发生在窗口得到焦点的时候。应用于：window 对象
onload 事件发生在文档全部下载完毕的时候。全部下载完毕意味着不但
HTML 文件，而且包含的图片，插件，控件，小程序等全部内容都下载完
毕。本事件是 window 的事件，但是在 HTML 中指定事件处理程序的时候，
我们是把它写在标记中的。应用于：window 对象
onmousedown 事件发生在用户把鼠标放在对象上按下鼠标键的时候。参
考 onmouseup 事件。应用于：Button 对象；Link 对象
onmouseout 事件发生在鼠标离开对象的时候。参考 onmouseover 事件。
应用于：Link 对象
onmouseover 事件发生在鼠标进入对象范围的时候。这个事件和
onmouseout 事件，再加上图片的预读，就可以做到当鼠标移到图像连接
上，图像更改的效果了。有时我们看到，在指向一个连接时，状态栏上不
显示地址，而显示其它的资料，看起来这些资料是可以随时更改的。它们
是这样做出来的：

应用于：Link 对象
onmouseup 事件发生在用户把鼠标放在对象上鼠标键被按下的情况下，
放开鼠标键的时候。如果按下鼠标键的时候，鼠标并不在放开鼠标的对象
上，则本事件不会发生。应用于：Button 对象；Link 对象

onreset 事件发生在表单的“重置”按钮被单击（按下并放开）的时候。
通过在事件处理程序中返回 false 值（return false）可以阻止表单重
置。应用于：Form 对象
onresize 事件发生在窗口被调整大小的时候。应用于：window 对象
onsubmit 事件发生在表单的“提交”按钮被单击（按下并放开）的时候。
可以使用该事件来验证表单的有效性。通过在事件处理程序中返回 false
值（return false）可以阻止表单提交。应用于：Form 对象
onunload 事件发生在用户退出文档（或者关闭窗口，或者到另一个页面
去）的时候。与 onload 一样，要写在 HTML 中就写到标记里。
有的 Web Masters 用这个方法来弹出“调查表单”，以“强迫”来者填
写；有的就弹出广告窗口，唆使来者点击连接。我觉得这种
“οnunlοad="open..."”的方法很不好，有时甚至会因为弹出太多窗口而
导致资源缺乏。有什么对来者说就应该在网页上说完，不对吗？应用于：
window 对象

javascript的Document 对象

Document 文档对象是JavaScript 中window 和frames 对象的一个属性,是显示
于窗口或框架内的一个文档。描述当前窗口或指定窗口对象的文档。它包含了文
档从到的内容。
用法：document （当前窗口）或 <窗口对象>.document （指定窗口）
属性：
document.title //设置文档标题等价于HTML 的标签 document.bgColor //设置页面背景色 document.fgColor //设置前景色(文本颜色) document.linkColor //未点击过的链接颜色 document.alinkColor //激活链接(焦点在此链接上)的颜色 document.vlinkColor //已点击过的链接颜色 document.URL //设置URL 属性从而在同一窗口打开另一网页 document.fileCreatedDate //文件建立日期，只读属性 document.fileModifiedDate //文件修改日期，只读属性 document.fileSize //文件大小，只读属性 document.cookie //设置和读出cookie document.charset //设置字符集简体中文:gb2312 cookie 关于 cookie 请参看“使用框架和 Cookies”一章。 lastModified 当前文档的最后修改日期，是一个 Date 对象。 referrer 如果当前文档是通过点击连接打开的，则 referrer 返回原来 的 URL。 title 指<head>标记里用<title>...定义的文字。在 Netscape
里本属性不接受赋值。
fgColor 指标记的 text 属性所表示的文本颜色。
bgColor 指标记的 bgcolor 属性所表示的背景颜色。
linkColor 指标记的 link 属性所表示的连接颜色。
alinkColor 指标记的 alink 属性所表示的活动连接颜色。
vlinkColor 指标记的 vlink 属性所表示的已访问连接颜色。
方法：
open() 打开文档以便 JavaScript 能向文档的当前位置（指插入
JavaScript 的位置）写入数据。通常不需要用这个方法，在需要的时候
JavaScript 自动调用。
write(); writeln() 向文档写入数据，所写入的会当成标准文档 HTML
来处理。writeln() 与 write() 的不同点在于，writeln() 在写入数据
以后会加一个换行。这个换行只是在 HTML 中换行，具体情况能不能够是
显示出来的文字换行，要看插入 JavaScript 的位置而定。如在

标 
    
 记中插入，这个换行也会体现在文档中。 
    
 clear() 清空当前文档。 
    
 close() 关闭文档，停止写入数据。如果用了 write[ln]() 或 clear() 
    
 方法，就一定要用 close() 方法来保证所做的更改能够显示出来。如果 
    
 文档还没有完全读取，也就是说，JavaScript 是插在文档中的，那就不 
    
 必使用该方法。

javascript的location对象的方法

location 地址对象它描述的是某一个窗口对象所打开的地址。要表示当前窗口
的地址，只需要使用“location”就行了；若要表示某一个窗口的地址，就使用
“<窗口对象>.location”。先前写了一片用window.location.href实现刷新另
个框架页面，特此我看了一下locaiton 的详细用法，对此有点改进，具体如
下：
注意：属于不同协议或不同主机的两个地址之间不能互相引用对方的 location
对象，这是出于安全性的需要。例如，当前窗口打开的是“www.a.com”下面的
某一页，另外一个窗口（对象名为：bWindow）打开的是“www.b.com”的网页。
如果在当前窗口使用“bWindow.location”，就会出错：“没有权限”。这个错
误是不能用错误处理程序（Event Handler，参阅 onerror 事件)来接收处理的。
第一、简单介绍一下location 属性、用法以及相关示例：
Location
包含了关于当前 URL 的信息。location 对象描述了与一个给定的 Window 对象
关联的完整 URL。location 对象的每个属性都描述了 URL 的不同特性。
通常情况下，一个 URL 会有下面的格式：协议//主机:端口/路径名称#哈希标识?
搜索条件
例如：url 这
些部分是满足下列需求的：
“协议”是 URL 的起始部分，直到包含到第一个冒号。
“主机”描述了主机和域名，或者一个网络主机的 IP 地址。
“端口”描述了服务器用于通讯的通讯端口。
路径名称描述了 URL 的路径方面的信息。
“哈希标识”描述了 URL 中的锚名称，包括哈希掩码(#)。此属性只应用
于 HTTP 的 URL。
“搜索条件”描述了该 URL 中的任何查询信息，包括问号。此属性只应
用于 HTTP 的 URL。“搜索条件”字符串包含变量和值的配对；每对之间
由一个“&”连接。
属性概览
protocol 返回地址的协议，取值为 'http:','https:','file:' 等等。
hostname 返回地址的主机名，例如，一个“
http://www.microsoft.com/china/”的地址，location.hostname ==
'www.microsoft.com'。
· port 返回地址的端口号，一般 http 的端口号是 '80'。
· host 返回主机名和端口号，如：'www.a.com:8080'。
· pathname 返回路径名，如“http://www.a.com/b/c.html”，
location.pathname == 'b/c.html'。
· hash 返回“#”以及以后的内容，如“
http://www.a.com/b/c.html#chapter4”，location.hash ==
'#chapter4'；如果地址里没有“#”，则返回空字符串。
· search 返回“?”以及以后的内容，如“
http://www.a.com/b/c.asp?selection=3&jumpto=4”，l ocation.search
== '?selection=3&jumpto=4'；如果地址里没有“?”，则返回空字符串。
href 返回以上全部内容，也就是说，返回整个地址。在浏览器的地址栏
上怎么显示它就怎么返回。如果想一个窗口对象打开某地址，可以使用
“location.href = '...'”，也可以直接用“location = '...'”来达
到此目的。
方法概览
reload() 相当于按浏览器上的“刷新”(IE)或“Reload”(Netscape)
键。
replace() 打开一个 URL，并取代历史对象中当前位置的地址。用这个方
法打开一个 URL 后，按下浏览器的“后退”键将不能返回到刚才的页面。
location 之页面跳转js 如下：
//简单跳转
function gotoPage(url) {
// eg. var url =
"newsview.html?catalogid="+catalogID+"&pageid="+pageid;
window.location = url;
}
// 对location 用法的升级，为单个页面传递参数
function goto_catalog(iCat) {
if(iCat<=0) {
top.location = "../index.aspx"; // top 出去
} else {
window.location = "../newsCat.aspx?catid="+iCat;
}
}
对指定框架进行跳转页面，二种方法皆可用
function goto_iframe(url) {
parent.mainFrame.location = "../index.aspx"; //
// parent.document.getElementById("mainFrame").src =
"../index.aspx";// use dom to change page // 同时我增加了dom 的写法
}
// 对指定框架进行跳转页面，因为
parent.iframename.location="../index.aspx"; 方法不能实行，主要是
"parent.iframename" 中的iframename在js 中被默认为节点，而不能把传递过
来的参数转换过来，所以用dom 实现了该传递二个参数的框架跳转页面，希望那
位仁兄不吝赐教！
function goto_iframe(iframename,url) {
parent.document.getElementById(iframename).src = "../index.aspx";//
use dom to change page by iframeName
//}
// 回到首页
function gohome() {
top.location = "/index.aspx";
}

JavaScript 中的History 历史对象

JavaScript 中的History 历史对象包含了用户已浏览的 URL 的信息，是指历史
对象指浏览器的浏览历史。鉴于安全性的需要，该对象收到很多限制，现在只剩
下下列属性和方法。History 历史对象有length 这个属性，列出历史的项数。
JavaScript 所能管到的历史被限制在用浏览器的“前进”“后退”键可以去到
的范围。本属性返回的是“前进”和“后退”两个按键之下包含的地址数的和。
History 历史对象并有以下方法
back() 后退，跟按下“后退”键是等效的。
forward() 前进，跟按下“前进”键是等效的。
go() 用法：history.go(x)；在历史的范围内去到指定的一个地址。如果
x < 0，则后退 x 个地址，如果 x > 0，则前进 x 个地址，如果 x == 0，
则刷新现在打开的网页。history.go(0) 跟 location.reload() 是等效
的。

javascript的window对象的方法

Window是JavaScript 中最大的对象，它描述的是一个浏览器窗口。一般要引用它的
属性和方法时，不需要用“window.xxx”这种形式，而直接使用“xxx”。一个
框架页面也是一个窗口。
Window 窗口对象有如下属性：
name 窗口的名称，由打开它的连接（）或框架页（ name="...">）或某一个窗口调用的 open() 方法（见下）决定。一般我
们不会用这个属性。
status 指窗口下方的“状态栏”所显示的内容。通过对 status 赋值，
可以改变状态栏的显示。
opener 用法：window.opener；返回打开本窗口的窗口对象。注意：返回
的是一个窗口对象。如果窗口不是由其他窗口打开的，在 Netscape 中这
个属性返回 null；在 IE 中返回“未定义”（ undefined）。u ndefined 在
一定程度上等于 null。注意：undefined 不是 JavaScript 常数，如果
你企图使用“undefined”，那就真的返回“未定义”了。
self 指窗口本身，它返回的对象跟 window 对象是一模一样的。最常用
的是“self.close()”，放在标记中：“ href="javascript:self.close()">关闭窗口”。
parent 返回窗口所属的框架页对象。
top 返回占据整个浏览器窗口的最顶端的框架页对象。
history 历史对象，
location 地址对象，
document 文档对象，
Window 窗口对象有如下方法：
第一个方法是open() 打开一个窗口。
用法：
open(, <窗口名称字符串>, <参数字符串>);
说明：
：描述所打开的窗口打开哪一个网页。如果留空（''），则
不打开任意网页。
<窗口名称字符串>：描述被打开的窗口的名称（window.name），可以使
用'_top'、'_blank'等内建名称。这里的名称跟“ target="...">”里的“target”属性是一样的。
<参数字符串>：描述被打开的窗口的样貌。如果只需要打开一个普通窗口，
该字符串留空（''），如果要指定样貌，就在字符串里写上一到多个参数，
参数之间用逗号隔开。
例：打开一个 400 x 100 的干净的窗口：
open('','_blank','width=400,height=100,menubar=no,toolbar=no,
location=no,directories=no,status=no, scrollbars=yes,resizable=yes')
open()的参数
top=# 窗口顶部离开屏幕顶部的像素数
left=# 窗口左端离开屏幕左端的像素数
width=# 窗口的宽度
height=# 窗口的高度
menubar=... 窗口有没有菜单，取值yes 或no
toolbar=... 窗口有没有工具条，取值yes 或 no
location=... 窗口有没有地址栏，取值yes 或no
directories=... 窗口有没有连接区，取值yes 或no
scrollbars=... 窗口有没有滚动条，取值yes 或no
status=... 窗口有没有状态栏，取值yes 或no
resizable=... 窗口给不给调整大小，取值yes 或no
注意：open() 方法有返回值，返回的就是它打开的窗口对象。比如
var newWindow = open('','_blank');
这样把一个新窗口赋值到“newWindow”变量中，以后通过“newWindow”变量就
可以控制窗口了。
close() 关闭一个已打开的窗口。
用法：
window.close()
或
self.close()
主要作用是关闭本窗口；
<窗口对象>.close()：关闭指定的窗口。注意如果该窗口有状态栏，调用该方法
后浏览器会警告：“网页正在试图关闭窗口，是否关闭？”然后等待用户选择是
否；如果没有状态栏，调用该方法将直接关闭窗口。
另外Window 窗口对象还有如下方法
blur() 使焦点从窗口移走，窗口变为“非活动窗口”。
focus() 是窗口获得焦点，变为“活动窗口”。不过在 Windows 98，该
方法只能使窗口的标题栏和任务栏上的相应按钮闪烁，提示用户该窗口正
在试图获得焦点。
scrollTo() 用法：&e1;<窗口对象>.&e3;scrollTo(x, y)；使窗口滚动，使文档
从左上角数起的(x, y)点滚动到窗口的左上角。
scrollBy() 用法：&e1;<窗口对象>.&e3;scrollBy(deltaX, deltaY)；使窗口向
右滚动 deltaX 像素，向下滚动 deltaY 像素。如果取负值，则向相反的
方向滚动。
resizeTo() 用法：&e1;<窗口对象>.&e3;resizeTo(width, height)；使窗口调
整大小到宽 width 像素，高 height 像素。
resizeBy() 用法：&e1;<窗口对象>.&e3;resizeBy(deltaWidth, deltaHeight)；
使窗口调整大小，宽增大 deltaWidth 像素，高增大 deltaHeight 像素。
如果取负值，则减少。
alert() 用法：alert(<字符串>)；弹出一个只包含“确定”按钮的对话
框，显示<字符串>的内容，整个文档的读取、Script 的运行都会暂停，
直到用户按下“确定”。
confirm() 用法：c onfirm(<字符串>)；弹出一个包含“确定”和“取消”
按钮的对话框，显示<字符串>的内容，要求用户做出选择，整个文档的读
取、Script 的运行都会暂停。如果用户按下“确定”，则返回 true 值，
如果按下“取消”，则返回 false 值。
prompt() 用法：prompt(<字符串>[, <初始值>])；弹出一个包含“确
认”“取消”和一个文本框的对话框，显示<字符串>的内容，要求用户在
文本框输入一些数据，整个文档的读取、Script 的运行都会暂停。如果
用户按下“确认”，则返回文本框里已有的内容，如果用户按下“取消”，
则返回 null 值。如果指定<初始值>，则文本框里会有默认值。
Window 窗口对象有如下事件：
window.onload;发生在文档全部下载完毕的时候。全部下载完毕意味着不但
HTML 文件，而且包含的图片，插件，控件，小程序等全部内容都下载完毕。本
事件是 window 的事件，但是在 HTML 中指定事件处理程序的时候，我们是把它
写在标记中的。
window.onunload;发生在用户退出文档（或者关闭窗口，或者到另一个页面去）
的时候。与 onload 一样，要写在 HTML 中就写到标记里。
window.onresize;发生在窗口被调整大小的时候。
window.onblur;发生在窗口失去焦点的时候。
window.onfocus;发生在窗口得到焦点的时候。
window.onerror;发生在错误发生的时候。它的事件处理程序通常就叫做
“错误处理程序”(Error Handler)，用来处理错误。上边已经介绍过，
要忽略一切错误，就使用：
function ignoreError() {
return true;
}
window.onerror = ignoreError;

javascript的navigator对象

navigator 浏览器对象，包含了正在使用的 Navigator 的版本信息。反映了当
前使用的浏览器的资料。JavaScript 客户端运行时刻引擎自动创建 navigator
对象。
包括一下几大属性：
· appCodeName 返回浏览器的“码名”(?)，流行的 IE 和 NN 都返回
'Mozilla'。
下面的例子显示了 appCodeName 属性的值：
document.write("navigator.appCodeName 的值是" +
navigator.appCodeName)
· appName 返回浏览器名。I E 返回 'Microsoft Internet Explorer'，N N 返
回 'Netscape'。
下面的例子显示了 appName 属性的值：
document.write("navigator.appName 的值是 " + navigator.appName)
· appVersion 返回浏览器版本，包括了大版本号、小版本号、语言、操作
平台等信息。
· language 语言
· mimeType 以数组表示所支持的MIME 类型
· platform 返回浏览器的操作平台，对于 Windows 9x 上的浏览器，返回
'Win32'（大小写可能有差异）。
· userAgent 返回以上全部信息。例如，IE5.01 返回 'Mozilla/4.0
(compatible; MSIE 5.01; Windows 98)'。
· plugins 以数组表示已安装的外挂程序
· javaEnabled() 返回一个布尔值，代表当前浏览器允许不允许 Java。

javascript日期操作

以下有很多“g/set[UTC]XXX”这样的方法，它表示既有“getXXX”方法，又有
“setXXX”方法。“get”是获得某个数值，而“set”是设定某个数值。如果带
有“UTC”字母，则表示获得/设定的数值是基于 UTC 时间的，没有则表示基于
本地时间或浏览期默认时间的。
如无说明，方法的使用格式为：“<对象>.<方法>”，下同。
g/set[UTC]FullYear() 返回/设置年份，用四位数表示。如果使用
“x.set[UTC]FullYear(99)”，则年份被设定为 0099 年。
g/set[UTC]Year()返回/设置年份，用两位数表示。设定的时候浏览器自动加上
“19”开头，故使用“x.set[UTC]Year(00)”把年份设定为 1900 年。
g/set[UTC]Month()返回/设置月份。
g/set[UTC]Date()返回/设置日期。
g/set[UTC]Day()返回/设置星期，0 表示星期天。
g/set[UTC]Hours()返回/设置小时数，24 小时制。
g/set[UTC]Minutes()返回/设置分钟数。
g/set[UTC]Seconds()返回/设置秒钟数。
g/set[UTC]Milliseconds()返回/设置毫秒数。
g/setTime() 返回/设置时间，该时间就是日期对象的内部处理方法：从 1970 年
1 月 1 日零时正开始计算到日期对象所指的日期的毫秒数。如果要使某日期对
象所指的时间推迟 1 小时，就用：“x.setTime(x.getTime() + 60 * 60 *
1000);”（一小时 60 分，一分 60 秒，一秒 1000 毫秒）。
getTimezoneOffset() 返回日期对象采用的时区与格林威治时间所差的分钟数。
在格林威治东方的市区，该值为负，例如：中国时区（GMT+0800）返回“-480”。
toString() 返回一个字符串，描述日期对象所指的日期。这个字符串的格式类
似于：“Fri Jul 21 15:43:46 UTC+0800 2000”。
toLocaleString() 返回一个字符串，描述日期对象所指的日期，用本地时间表
示格式。如：“2000-07-21 15:43:46”。
toGMTString() 返回一个字符串，描述日期对象所指的日期，用 GMT 格式。
toUTCString() 返回一个字符串，描述日期对象所指的日期，用 UTC 格式。
parse() 用法：Date.parse(<日期对象>)；返回该日期对象的内部表达方式。

javascriptMath函数的属性和用法

Math “数学”对象，提供对数据的数学计算。下面所提到的属性和方法，大家在使用的时候记住用“Math.<名>”这种格式。
属性
E 返回常数 e (2.718281828...)。
LN2 返回 2 的自然对数 (ln 2)。
LN10 返回 10 的自然对数 (ln 10)。
LOG2E 返回以 2 为低的 e 的对数 (log2e)。
LOG10E 返回以 10 为低的 e 的对数 (log10e)。
PI 返回π（3.1415926535...)。
SQRT1_2 返回 1/2 的平方根。
SQRT2 返回 2 的平方根。
方法
abs(x) 返回 x 的绝对值。
acos(x) 返回 x 的反余弦值（余弦值等于 x 的角度），用弧度表示。
asin(x) 返回 x 的反正弦值。
atan(x) 返回 x 的反正切值。
atan2(x, y) 返回复平面内点(x, y)对应的复数的幅角，用弧度表示，其值在 -π
到 π 之间。
ceil(x) 返回大于等于 x 的最小整数。
cos(x) 返回 x 的余弦。
exp(x) 返回 e 的 x 次幂 (ex)。
floor(x) 返回小于等于 x 的最大整数。
log(x) 返回 x 的自然对数 (ln x)。
max(a, b) 返回 a, b 中较大的数。
min(a, b) 返回 a, b 中较小的数。
pow(n, m) 返回 n 的 m 次幂 (nm)。
random() 返回大于 0 小于 1 的一个随机数。
round(x) 返回 x 四舍五入后的值。
sin(x) 返回 x 的正弦。
sqrt(x) 返回 x 的平方根。
tan(x) 返回 x 的正切。
Date 日期对象。这个对象可以储存任意一个日期，从 0001 年到 9999 年，并
且可以精确到毫秒数（ 1/1000 秒）。在内部，日期对象是一个整数，它是从 1970
年 1 月 1 日零时正开始计算到日期对象所指的日期的毫秒数。如果所指日期比
1970 年早，则它是一个负数。所有日期时间，如果不指定时区，都采用“UTC”
（世界时）时区，它与“GMT”（格林威治时间）在数值上是一样的。
定义一个日期对象：
var d = new Date;
这个方法使 d 成为日期对象，并且已有初始值：当前时间。如果要自定初始值，
可以用：
var d = new Date(99, 10, 1); //99 年 10 月 1 日
var d = new Date('Oct 1, 1999'); //99 年 10 月 1 日

javascript字符串属性和方法

jquery事件类型

jquery自定义事件

jquery移除事件

jquery得到事件类型，href，

click me .

jquery阻止表单提交

jquery事件冒泡

   外层div元素
   内层span元素
   外层div元素

jquery隐藏显示的合成事件

什么是jQuery?

jQuery是继Prototype之后又一个优秀的JavaScript库，它是一个由 John Resig 创建于2006年1月的开源项目。jQuery凭借简洁的语法和

跨平台的兼容性，极大地简化了JavaScript开发人员遍历HTML文档、操作DOM、处理事件、执行动画和开发Ajax。它独特而又优雅的代码风格改变了

JavaScript程序员的设计思路和编写程序的方式。

什么是jQuery?

jquery点击，鼠标模块的隐藏和显示

什么是jQuery?

jquery加载时间比较

jquery表单操作

表单对象属性过滤选择器.

     可用元素：

     不可用元素：

     可用元素：

   不可用元素：



     多选框：

   test1
     test2
     test3
     test4
     test5

     下拉列表1：





     下拉列表2：

jquery选择器

//选取每个父元素下的第2个子元素
      $('#btn1').click(function(){
          $('div.one :nth-child(2)').css("background","#bbffaa");
      })
      //选取每个父元素下的第一个子元素
      $('#btn2').click(function(){
          $('div.one :first-child').css("background","#bbffaa");
      })
      //选取每个父元素下的最后一个子元素
      $('#btn3').click(function(){
          $('div.one :last-child').css("background","#bbffaa");
      })
      //如果父元素下的仅仅只有一个子元素，那么选中这个子元素
      $('#btn4').click(function(){
          $('div.one :only-child').css("background","#bbffaa");
      })
//选取含有属性title 的div元素.
      $('#btn1').click(function(){
          $('div[title]').css("background","#bbffaa");
      })
      //选取属性title值等于 test 的div元素.
      $('#btn2').click(function(){
          $('div[title=test]').css("background","#bbffaa");
      })
      //选取属性title值不等于 test 的div元素.
      $('#btn3').click(function(){
          $('div[title!=test]').css("background","#bbffaa");
      })
      //选取属性title值以 te 开始的div元素.
      $('#btn4').click(function(){
          $('div[title^=te]').css("background","#bbffaa");
      })
      //选取属性title值以 est 结束的div元素.
      $('#btn5').click(function(){
          $("div[title$=est]").css("background","#bbffaa");
      })
      //选取属性title值含有 es 的div元素.
      $('#btn6').click(function(){
          $("div[title*=es]").css("background","#bbffaa");
      })
      //组合属性选择器,首先选取有属性id的div元素，然后在结果中选取属性title值含有 es 的元素.
      $('#btn7').click(function(){
          $("div[id][title*=es]").css("background","#bbffaa");
      })
$('#reset').click(function(){
          window.location.reload();
      })
      //给id为mover的元素添加动画.
       function animateIt() {
          $("#mover").slideToggle("slow", animateIt);
        }
       animateIt();

       //选取所有不可见的元素.包括.
      $('#btn_hidden').click(function(){
          alert( "不可见的元素有："+$('body :hidden').length +"个!\n"+
           "其中不可见的div元素有:"+$('div:hidden').length+"个!\n"+
           "其中文本隐藏域有:"+$('input:hidden').length+"个!");
          $('div:hidden').show(3000).css("background","#bbffaa");
      })
      //选取所有可见的元素.
      $('#btn_visible').click(function(){
          $('div:visible').css("background","#FF6500");
      })
//选取含有文本"di"的div元素.
      $('#btn1').click(function(){
          $('div:contains(di)').css("background","#bbffaa");
      })
      //选取不包含子元素(或者文本元素)的div空元素.
      $('#btn2').click(function(){
          $('div:empty').css("background","#bbffaa");
      })
      //选取含有class为mini元素的div元素.
      $('#btn3').click(function(){
          $('div:has(.mini)').css("background","#bbffaa");
      })
      //选取含有子元素(或者文本元素)的div元素.
      $('#btn4').click(function(){
          $('div:parent').css("background","#bbffaa");
      })
//选择第一个div元素.
      $('#btn1').click(function(){
          $('div:first').css("background","#bfa");
      })
      //选择最后一个div元素.
      $('#btn2').click(function(){
          $('div:last').css("background","#bfa");
      })
      //选择class不为one的所有div元素.
      $('#btn3').click(function(){
          $('div:not(.one)').css("background","#bfa");
      })
      //选择索引值为偶数的div元素。
      $('#btn4').click(function(){
          $('div:even').css("background","#bfa");
      })
      //选择索引值为奇数的div元素。
      $('#btn5').click(function(){
          $('div:odd').css("background","#bfa");
      })
      //选择索引等于 3 的元素
      $('#btn6').click(function(){
          $('div:eq(3)').css("background","#bfa");
      })
      //选择索引大于 3 的元素
      $('#btn7').click(function(){
          $('div:gt(3)').css("background","#bfa");
      })
   //选择索引小于 3 的元素
      $('#btn8').click(function(){
          $('div:lt(3)').css("background","#bfa");
      })
       //选择所有的标题元素.比如h1, h2, h3等等...
      $('#btn9').click(function(){
          $(':header').css("background","#bfa");
      })
      //选择当前正在执行动画的所有元素.
      $('#btn10').click(function(){
          $(':animated').css("background","#bfa");
      });
//选择 body内的所有div元素.
      $('#btn1').click(function(){
          $('body div').css("background","#bbffaa");
      })
      //在body内的选择元素名是div 的子元素.
      $('#btn2').click(function(){
          $('body > div').css("background","#bbffaa");
      })
      //选择所有class为one 的下一个div元素.
      $('#btn3').click(function(){
          $('.one + div').css("background","#bbffaa");
      })
      //选择 id为two的元素后面的所有div兄弟元素.
      $('#btn4').click(function(){
           $('#two ~ div').css("background","#bbffaa");
      })
//选择 id为 one 的元素
      $('#btn1').click(function(){
          $('#one').css("background","#bfa");
      });
      //选择 class 为 mini 的所有元素
      $('#btn2').click(function(){
          $('.mini').css("background","#bfa");
      });
      //选择元素名是 div 的所有元素
      $('#btn3').click(function(){
          $('div').css("background","#bfa");
      });
      //选择所有的元素
      $('#btn4').click(function(){
          $('*').css("background","#bfa");
      });
      //选择所有的span元素和id为two的div元素
      $('#btn5').click(function(){
          $('span,#two').css("background","#bfa");
      });

jquery文字提示

jquery遍历节点树

你最喜欢的水果是?

苹果

橘子

菠萝

你最喜欢的水果是?

苹果

橘子

菠萝

你最喜欢的水果是?

苹果

橘子

菠萝

jquery设置和获取HTML,文本和值

你最喜欢的水果是?

苹果

橘子

菠萝

多选1
多选2
多选3
多选4

单选1
单选2
单选3

jquery样式操作

你最喜欢的水果是?

苹果

橘子

菠萝

你最喜欢的水果是?

苹果

橘子

菠萝

jquery替换节点和属性操作

替换节点

你最喜欢的水果是?

苹果

橘子

菠萝

属性操作

你最喜欢的水果是?

苹果

橘子

菠萝

jquery删除和复制节点

删除节点

你最喜欢的水果是?

苹果

橘子

菠萝

复制节点

你最喜欢的水果是?

苹果

橘子

菠萝

jquery插入和移动节点

插入节点

你最喜欢的水果是?

苹果

橘子

菠萝

移动节点

你最喜欢的水果是?

苹果

橘子

菠萝

jquery查找和创建节点

得到元素的值

你最喜欢的水果是?

苹果

橘子

菠萝

创建节点

3-2-3

你最喜欢的水果是?

苹果

橘子

菠萝

dwr的简单例子

1.在lib中加入相应的dwr.jar包
2.在web.xml中加入以下代码：

dwr-invoker

org.directwebremoting.servlet.DwrServlet

debug

true

dwr-invoker

/dwr/*

3.在web-inf目录下新建dwr.xml文件，加入一个简单的配置：

4.新建一个servlet类，

public class Service {

public String sayHello(String yourName){

return yourName;

}

5.新建一个jsp页面如下：

My JSP 'index.jsp' starting page

当点击按钮时，就会弹出yangjunwei，这就完成了一个简单的dwrajax交互

手机访问网站拦截请求头信息类

public class HttpRequestDeviceUtils {

 /**Wap网关Via头信息中特有的描述信息*/
 private static String mobileGateWayHeaders[]=new String[]{
 "ZXWAP",//中兴提供的wap网关的via信息，例如：Via=ZXWAP GateWayZTE Technologies，
 "chinamobile.com",//中国移动的诺基亚wap网关，例如：Via=WTP/1.1 GDSZ-PB-GW003-WAP07.gd.chinamobile.com (Nokia WAP Gateway 4.1 CD1/ECD13_D/4.1.04)
 "monternet.com",//移动梦网的网关，例如：Via=WTP/1.1 BJBJ-PS-WAP1-GW08.bj1.monternet.com. (Nokia WAP Gateway 4.1 CD1/ECD13_E/4.1.05)
 "infoX",//华为提供的wap网关，例如：Via=HTTP/1.1 GDGZ-PS-GW011-WAP2 (infoX-WISG Huawei Technologies)，或Via=infoX WAP Gateway V300R001 Huawei Technologies
 "XMS 724Solutions HTG",//国外电信运营商的wap网关，不知道是哪一家
 "wap.lizongbo.com",//自己测试时模拟的头信息
 "Bytemobile",//貌似是一个给移动互联网提供解决方案提高网络运行效率的，例如：Via=1.1 Bytemobile OSN WebProxy/5.1
 };
 /**电脑上的IE或Firefox浏览器等的User-Agent关键词*/
 private static String[] pcHeaders=new String[]{
 "Windows 98",
 "Windows ME",
 "Windows 2000",
 "Windows XP",
 "Windows NT",
 "Ubuntu"
 };
 /**手机浏览器的User-Agent里的关键词*/
 private static String[] mobileUserAgents=new String[]{
 "Nokia",//诺基亚，有山寨机也写这个的，总还算是手机，Mozilla/5.0 (Nokia5800 XpressMusic)UC AppleWebkit(like Gecko) Safari/530
 "SAMSUNG",//三星手机 SAMSUNG-GT-B7722/1.0+SHP/VPP/R5+Dolfin/1.5+Nextreaming+SMM-MMS/1.2.0+profile/MIDP-2.1+configuration/CLDC-1.1
 "MIDP-2",//j2me2.0，Mozilla/5.0 (SymbianOS/9.3; U; Series60/3.2 NokiaE75-1 /110.48.125 Profile/MIDP-2.1 Configuration/CLDC-1.1 ) AppleWebKit/413 (KHTML like Gecko) Safari/413
 "CLDC1.1",//M600/MIDP2.0/CLDC1.1/Screen-240X320
 "SymbianOS",//塞班系统的，
 "MAUI",//MTK山寨机默认ua
 "UNTRUSTED/1.0",//疑似山寨机的ua，基本可以确定还是手机
 "Windows CE",//Windows CE，Mozilla/4.0 (compatible; MSIE 6.0; Windows CE; IEMobile 7.11)
 "iPhone",//iPhone是否也转wap？不管它，先区分出来再说。Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_1 like Mac OS X; zh-cn) AppleWebKit/532.9 (KHTML like Gecko) Mobile/8B117
 "iPad",//iPad的ua，Mozilla/5.0 (iPad; U; CPU OS 3_2 like Mac OS X; zh-cn) AppleWebKit/531.21.10 (KHTML like Gecko) Version/4.0.4 Mobile/7B367 Safari/531.21.10
 "Android",//Android是否也转wap？Mozilla/5.0 (Linux; U; Android 2.1-update1; zh-cn; XT800 Build/TITA_M2_16.22.7) AppleWebKit/530.17 (KHTML like Gecko) Version/4.0 Mobile Safari/530.17
 "BlackBerry",//BlackBerry8310/2.7.0.106-4.5.0.182
 "UCWEB",//ucweb是否只给wap页面？ Nokia5800 XpressMusic/UCWEB7.5.0.66/50/999
 "ucweb",//小写的ucweb貌似是uc的代理服务器Mozilla/6.0 (compatible; MSIE 6.0;) Opera ucweb-squid
 "BREW",//很奇怪的ua，例如：REW-Applet/0x20068888 (BREW/3.1.5.20; DeviceId: 40105; Lang: zhcn) ucweb-squid
 "J2ME",//很奇怪的ua，只有J2ME四个字母
 "YULONG",//宇龙手机，YULONG-CoolpadN68/10.14 IPANEL/2.0 CTC/1.0
 "YuLong",//还是宇龙
 "COOLPAD",//宇龙酷派YL-COOLPADS100/08.10.S100 POLARIS/2.9 CTC/1.0
 "TIANYU",//天语手机TIANYU-KTOUCH/V209/MIDP2.0/CLDC1.1/Screen-240X320
 "TY-",//天语，TY-F6229/701116_6215_V0230 JUPITOR/2.2 CTC/1.0
 "K-Touch",//还是天语K-Touch_N2200_CMCC/TBG110022_1223_V0801 MTK/6223 Release/30.07.2008 Browser/WAP2.0
 "Haier",//海尔手机，Haier-HG-M217_CMCC/3.0 Release/12.1.2007 Browser/WAP2.0
 "DOPOD",//多普达手机
 "Lenovo",// 联想手机，Lenovo-P650WG/S100 LMP/LML Release/2010.02.22 Profile/MIDP2.0 Configuration/CLDC1.1
 "LENOVO",// 联想手机，比如：LENOVO-P780/176A
 "HUAQIN",//华勤手机
 "AIGO-",//爱国者居然也出过手机，AIGO-800C/2.04 TMSS-BROWSER/1.0.0 CTC/1.0
 "CTC/1.0",//含义不明
 "CTC/2.0",//含义不明
 "CMCC",//移动定制手机，K-Touch_N2200_CMCC/TBG110022_1223_V0801 MTK/6223 Release/30.07.2008 Browser/WAP2.0
 "DAXIAN",//大显手机DAXIAN X180 UP.Browser/6.2.3.2(GUI) MMP/2.0
 "MOT-",//摩托罗拉，MOT-MOTOROKRE6/1.0 LinuxOS/2.4.20 Release/8.4.2006 Browser/Opera8.00 Profile/MIDP2.0 Configuration/CLDC1.1 Software/R533_G_11.10.54R
 "SonyEricsson",// 索爱手机，SonyEricssonP990i/R100 Mozilla/4.0 (compatible; MSIE 6.0; Symbian OS; 405) Opera 8.65 [zh-CN]
 "GIONEE",//金立手机
 "HTC",//HTC手机
 "ZTE",//中兴手机，ZTE-A211/P109A2V1.0.0/WAP2.0 Profile
 "HUAWEI",//华为手机，
 "webOS",//palm手机，Mozilla/5.0 (webOS/1.4.5; U; zh-CN) AppleWebKit/532.2 (KHTML like Gecko) Version/1.0 Safari/532.2 Pre/1.0
 "GoBrowser",//3g GoBrowser.User-Agent=Nokia5230/GoBrowser/2.0.290 Safari
 "IEMobile",//Windows CE手机自带浏览器，
 "WAP2.0"//支持wap 2.0的
 };
 /**
 * 根据当前请求的特征，判断该请求是否来自手机终端，主要检测特殊的头信息，以及user-Agent这个header
 * @param request http请求
 * @return 如果命中手机特征规则，则返回对应的特征字符串
 */
 public static boolean isMobileDevice(HttpServletRequest request){
 boolean b = false;
 boolean pcFlag = false;
 boolean mobileFlag = false;
 String via = request.getHeader("Via");
 String userAgent = request.getHeader("user-agent");
 for (int i = 0; via!=null && !via.trim().equals("") && i < mobileGateWayHeaders.length; i++) {
 if(via.contains(mobileGateWayHeaders[i])){
 mobileFlag = true;
 break;
 }
 }
 for (int i = 0;!mobileFlag && userAgent!=null && !userAgent.trim().equals("") && i < mobileUserAgents.length; i++) {
 if(userAgent.contains(mobileUserAgents[i])){
 mobileFlag = true;
 break;
 }
 }
 for (int i = 0; userAgent!=null && !userAgent.trim().equals("") && i < pcHeaders.length; i++) {
 if(userAgent.contains(pcHeaders[i])){
 pcFlag = true;
 break;
 }
 }
 if(mobileFlag==true && pcFlag==false){
 b=true;
 }
 return b;//false pc true shouji

 }

}

jfinal控制手机访问和电脑访问，跳转到不同的页面

可以写一个类继承Handler类，拦截所有的请求，得到url，根据请求头的信息判断出是手机访问还是电脑访问，根据需求跳转到不同的页面或者方法中

javascript笔记之onload和表单提交

火狐伪造请求头模拟手机访问网站

判断应该属于程序部分的处理，不属于前端的范畴，是靠判断请求头信息（HTTP_USER_AGENT）进行判断的。
步骤是：1.

首先需要安装三个Firefox插件：wmlbrowser、XHTML Mobile Profile、User Agent Switcher；（我称它们为“伪娘三贱客”）

安装好后需要设置 User Agent Switcher ，点击菜单工具 → Default User Agent → User Agent Switcher → Options → New→New User Agent... ，Description是你给它的一个称呼，比如小三，凹凸曼等等。关键的部分是User Agent里面的东西（这里是请求头主要的信息，程序会根据这个请求头进行判断你是否是手持设备），这里就需要把我们想要模拟的手持设备的信息填入了。

添加好后一路确定，回到浏览器界面。工具 →default user agent →选择你自己添加的那个 →在浏览器地址输入你想要访问的地址即可。
十分大方这里你会看到几个选项，Default User Agent (浏览器默认的信息)，Internet Explorer （可以模拟ie6,7,8的头信息），Search Robots （模拟谷歌，雅虎，msn的蜘蛛），iphone 3.0 （默认存在的一个）

下面列出几个比较常见手机的User Agent：(如果想要查询更多的手机user agent 信息的话，去看这里，还有这里)
iPhone3：
Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7A341 Safari/528.16
Android：
Mozilla/5.0 (Linux; U; Android 2.2; en-us; Nexus One Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1
诺基亚N95：
Mozilla/5.0 (SymbianOS/9.2; U; Series60/3.1 NokiaN95/30.0.015; Profile MIDP-2.0 Configuration/CLDC-1.1) AppleWebKit/413 (KHTML, like Gecko) Safari/413
诺基亚N97：
Mozilla/5.0 (SymbianOS/9.4; Series60/5.0 NokiaN97-1/20.0.019; Profile/MIDP-2.1 Configuration/CLDC-1.1) AppleWebKit/525 (KHTML, like Gecko) BrowserNG/7.1.18124

判断手机访问还是电脑访问

package pc;

import javax.servlet.http.HttpServletRequest;
public class HttpRequestDeviceUtils {

 /**Wap网关Via头信息中特有的描述信息*/
 private static String mobileGateWayHeaders[]=new String[]{
 "ZXWAP",//中兴提供的wap网关的via信息，例如：Via=ZXWAP GateWayZTE Technologies，
 "chinamobile.com",//中国移动的诺基亚wap网关，例如：Via=WTP/1.1 GDSZ-PB-GW003-WAP07.gd.chinamobile.com (Nokia WAP Gateway 4.1 CD1/ECD13_D/4.1.04)
 "monternet.com",//移动梦网的网关，例如：Via=WTP/1.1 BJBJ-PS-WAP1-GW08.bj1.monternet.com. (Nokia WAP Gateway 4.1 CD1/ECD13_E/4.1.05)
 "infoX",//华为提供的wap网关，例如：Via=HTTP/1.1 GDGZ-PS-GW011-WAP2 (infoX-WISG Huawei Technologies)，或Via=infoX WAP Gateway V300R001 Huawei Technologies
 "XMS 724Solutions HTG",//国外电信运营商的wap网关，不知道是哪一家
 "wap.lizongbo.com",//自己测试时模拟的头信息
 "Bytemobile",//貌似是一个给移动互联网提供解决方案提高网络运行效率的，例如：Via=1.1 Bytemobile OSN WebProxy/5.1
 };
 /**电脑上的IE或Firefox浏览器等的User-Agent关键词*/
 private static String[] pcHeaders=new String[]{
 "Windows 98",
 "Windows ME",
 "Windows 2000",
 "Windows XP",
 "Windows NT",
 "Ubuntu"
 };
 /**手机浏览器的User-Agent里的关键词*/
 private static String[] mobileUserAgents=new String[]{
 "Nokia",//诺基亚，有山寨机也写这个的，总还算是手机，Mozilla/5.0 (Nokia5800 XpressMusic)UC AppleWebkit(like Gecko) Safari/530
 "SAMSUNG",//三星手机 SAMSUNG-GT-B7722/1.0+SHP/VPP/R5+Dolfin/1.5+Nextreaming+SMM-MMS/1.2.0+profile/MIDP-2.1+configuration/CLDC-1.1
 "MIDP-2",//j2me2.0，Mozilla/5.0 (SymbianOS/9.3; U; Series60/3.2 NokiaE75-1 /110.48.125 Profile/MIDP-2.1 Configuration/CLDC-1.1 ) AppleWebKit/413 (KHTML like Gecko) Safari/413
 "CLDC1.1",//M600/MIDP2.0/CLDC1.1/Screen-240X320
 "SymbianOS",//塞班系统的，
 "MAUI",//MTK山寨机默认ua
 "UNTRUSTED/1.0",//疑似山寨机的ua，基本可以确定还是手机
 "Windows CE",//Windows CE，Mozilla/4.0 (compatible; MSIE 6.0; Windows CE; IEMobile 7.11)
 "iPhone",//iPhone是否也转wap？不管它，先区分出来再说。Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_1 like Mac OS X; zh-cn) AppleWebKit/532.9 (KHTML like Gecko) Mobile/8B117
 "iPad",//iPad的ua，Mozilla/5.0 (iPad; U; CPU OS 3_2 like Mac OS X; zh-cn) AppleWebKit/531.21.10 (KHTML like Gecko) Version/4.0.4 Mobile/7B367 Safari/531.21.10
 "Android",//Android是否也转wap？Mozilla/5.0 (Linux; U; Android 2.1-update1; zh-cn; XT800 Build/TITA_M2_16.22.7) AppleWebKit/530.17 (KHTML like Gecko) Version/4.0 Mobile Safari/530.17
 "BlackBerry",//BlackBerry8310/2.7.0.106-4.5.0.182
 "UCWEB",//ucweb是否只给wap页面？ Nokia5800 XpressMusic/UCWEB7.5.0.66/50/999
 "ucweb",//小写的ucweb貌似是uc的代理服务器Mozilla/6.0 (compatible; MSIE 6.0;) Opera ucweb-squid
 "BREW",//很奇怪的ua，例如：REW-Applet/0x20068888 (BREW/3.1.5.20; DeviceId: 40105; Lang: zhcn) ucweb-squid
 "J2ME",//很奇怪的ua，只有J2ME四个字母
 "YULONG",//宇龙手机，YULONG-CoolpadN68/10.14 IPANEL/2.0 CTC/1.0
 "YuLong",//还是宇龙
 "COOLPAD",//宇龙酷派YL-COOLPADS100/08.10.S100 POLARIS/2.9 CTC/1.0
 "TIANYU",//天语手机TIANYU-KTOUCH/V209/MIDP2.0/CLDC1.1/Screen-240X320
 "TY-",//天语，TY-F6229/701116_6215_V0230 JUPITOR/2.2 CTC/1.0
 "K-Touch",//还是天语K-Touch_N2200_CMCC/TBG110022_1223_V0801 MTK/6223 Release/30.07.2008 Browser/WAP2.0
 "Haier",//海尔手机，Haier-HG-M217_CMCC/3.0 Release/12.1.2007 Browser/WAP2.0
 "DOPOD",//多普达手机
 "Lenovo",// 联想手机，Lenovo-P650WG/S100 LMP/LML Release/2010.02.22 Profile/MIDP2.0 Configuration/CLDC1.1
 "LENOVO",// 联想手机，比如：LENOVO-P780/176A
 "HUAQIN",//华勤手机
 "AIGO-",//爱国者居然也出过手机，AIGO-800C/2.04 TMSS-BROWSER/1.0.0 CTC/1.0
 "CTC/1.0",//含义不明
 "CTC/2.0",//含义不明
 "CMCC",//移动定制手机，K-Touch_N2200_CMCC/TBG110022_1223_V0801 MTK/6223 Release/30.07.2008 Browser/WAP2.0
 "DAXIAN",//大显手机DAXIAN X180 UP.Browser/6.2.3.2(GUI) MMP/2.0
 "MOT-",//摩托罗拉，MOT-MOTOROKRE6/1.0 LinuxOS/2.4.20 Release/8.4.2006 Browser/Opera8.00 Profile/MIDP2.0 Configuration/CLDC1.1 Software/R533_G_11.10.54R
 "SonyEricsson",// 索爱手机，SonyEricssonP990i/R100 Mozilla/4.0 (compatible; MSIE 6.0; Symbian OS; 405) Opera 8.65 [zh-CN]
 "GIONEE",//金立手机
 "HTC",//HTC手机
 "ZTE",//中兴手机，ZTE-A211/P109A2V1.0.0/WAP2.0 Profile
 "HUAWEI",//华为手机，
 "webOS",//palm手机，Mozilla/5.0 (webOS/1.4.5; U; zh-CN) AppleWebKit/532.2 (KHTML like Gecko) Version/1.0 Safari/532.2 Pre/1.0
 "GoBrowser",//3g GoBrowser.User-Agent=Nokia5230/GoBrowser/2.0.290 Safari
 "IEMobile",//Windows CE手机自带浏览器，
 "WAP2.0"//支持wap 2.0的
 };
 /**
 * 根据当前请求的特征，判断该请求是否来自手机终端，主要检测特殊的头信息，以及user-Agent这个header
 * @param request http请求
 * @return 如果命中手机特征规则，则返回对应的特征字符串
 */
 public static boolean isMobileDevice(HttpServletRequest request){
 boolean b = false;
 boolean pcFlag = false;
 boolean mobileFlag = false;
 String via = request.getHeader("Via");
 String userAgent = request.getHeader("user-agent");
 for (int i = 0; via!=null && !via.trim().equals("") && i < mobileGateWayHeaders.length; i++) {
 if(via.contains(mobileGateWayHeaders[i])){
 mobileFlag = true;
 break;
 }
 }
 for (int i = 0;!mobileFlag && userAgent!=null && !userAgent.trim().equals("") && i < mobileUserAgents.length; i++) {
 if(userAgent.contains(mobileUserAgents[i])){
 mobileFlag = true;
 break;
 }
 }
 for (int i = 0; userAgent!=null && !userAgent.trim().equals("") && i < pcHeaders.length; i++) {
 if(userAgent.contains(pcHeaders[i])){
 pcFlag = true;
 break;
 }
 }
 if(mobileFlag==true && pcFlag==false){
 b=true;
 }
 return b;//false pc true shouji

 }

}

java年月日的操作

public static List getWeekDay(String strDate) {
       List list = new ArrayList();//第几周，周几
           String nReturn = null;
           Calendar c = Calendar.getInstance(); // 实例化一个Calendar对象
           c.clear(); // 清空Calendar
           c.set(Integer.parseInt(strDate.substring(0, 4)), Integer
                   .parseInt(strDate.substring(5, 7)) - 1, Integer
                   .parseInt(strDate.substring(8, 10))); // 设置这个日期的内容
           System.out.println("------------" + c.get(Calendar.YEAR) + "年" + (c.get(Calendar.MONTH) + 1) + "月"+(c.get(Calendar.DATE))+"日的天数和周数-------------");
            System.out.println("天数：" + c.getActualMaximum(Calendar.DAY_OF_MONTH));
            System.out.println("周数：" + c.getActualMaximum(Calendar.WEEK_OF_MONTH));
            System.out.println("第几周："+c.get(Calendar.DAY_OF_WEEK_IN_MONTH));
           switch (c.get(Calendar.DAY_OF_WEEK)) {
           case 1:
               nReturn = "7";
               break;
           case 2:
               nReturn = "1";
               break;
           case 3:
               nReturn = "2";
               break;
           case 4:
               nReturn = "3";
               break;
           case 5:
               nReturn = "4";
               break;
           case 6:
               nReturn = "5";
               break;
           case 7:
               nReturn = "6";
               break;
           default:
               nReturn = null;
               break;
           }
           list.add(String.valueOf(c.get(Calendar.DAY_OF_WEEK_IN_MONTH)));
           list.add(nReturn);
           return list;
       }

highcharts本地导出图片，pdf服务端代码

先要在exporting.js中修改导出图片的url是本地的服务器地址

String type = getPara("type");//getRequest().getParameter("type");
       String svg =getPara("svg");// getRequest().getParameter("svg");
       String filename = getPara("filename");//getRequest().getParameter("filename");
       ServletOutputStream out1 = null;
       try {
           //getRequest().setCharacterEncoding("utf-8");

           System.out.println(type);
           System.out.println(svg);
           System.out.println(filename);
           filename = filename==null?"chart":filename;
           out1 = getResponse().getOutputStream();
           if (null != type && null != svg) {
                svg = svg.replaceAll(":rect", "rect");
                String ext = "";
                Transcoder t = null;
                if (type.equals("image/png")) {
                   ext = "png";
                   t = new PNGTranscoder();
                } else if (type.equals("image/jpeg")) {
                   ext = "jpg";
                   t = new JPEGTranscoder();
                } else if(type.equals("image/svg+xml")) {
                      ext = "svg";
                }else if(type.equals("application/pdf")){
                   t = new PDFTranscoder();
                   ext = "pdf";
                }

                getResponse().addHeader("Content-Disposition", "attachment; filename="+ filename + "."+ext);
                getResponse().addHeader("Content-Type", type);

                if (null != t) {
                   TranscoderInput input = new TranscoderInput(new StringReader(svg));
                   TranscoderOutput output = new TranscoderOutput(out1);
                   try {
                        t.transcode(input, output);
                   } catch (TranscoderException e) {
                        out1.print("Problem transcoding stream. See the web logs for more details.");
                        e.printStackTrace();
                   }
                } else if (ext.equals("svg")) {
                //   out.print(svg);
                   OutputStreamWriter writer = new OutputStreamWriter(out1, "UTF-8");
                   writer.append(svg);
                   writer.flush();
                   writer.close();
                } /*else
                   out.print("Invalid type: " + type);*/
           } else {
               //getResponse().addHeader("Content-Type", "text/html");
               // out.println("Usage:\n\tParameter [svg]: The DOM Element to be converted." +
               //        "\n\tParameter [type]: The destination MIME type for the elment to be transcoded.");
           }

       } catch (Exception e) {
           e.printStackTrace();
       }finally{
           try {
               out1.flush();
               getResponse().flushBuffer();
               out1.close();

           } catch (Exception e2) {

           }

       }

需要的jar包：

extjs实现实时数据显示

Ext.namespace('Ext.ux');
Ext.ux.EmRealtimeDisplayPanel = function(treeNode, panelId, config) {
   this.treeNode = treeNode;
   this.panelId = panelId;


   var temhum = new Ext.form.ComboBox({
       name : 'temhunm',
       fieldLabel : '状态',
       allowBlank : false,
       blankText : '请选择温湿度',
       editable : false,
       triggerAction : 'all',//all表示把下拉框列表框的列表值全部显示出来
       store : new Ext.data.ArrayStore({
           fields : [ 'name', 'value' ],
           data : [ [ '温度', '1' ], [ '湿度', '2' ] ]
       }),
       mode : 'local',
       displayField : 'name',
       valueField : 'value',
       width : 60
   });
   var storenode = new Ext.data.JsonStore({   //读配置文件
        autoLoad:true,
        url : path+"/wenshi/getnode",
        root : "options",
        fields : [ {
            name : 'name'
        }]
   });

   var node = new Ext.form.ComboBox({
       fieldLabel : '节点',
       allowBlank : false,
       blankText : '请选择节点',
       editable : false,
       triggerAction : 'all',
       store : storenode,
       mode : 'local',
       displayField : 'name',
       valueField : 'name',
       width : 60
   });

   var dataArr = new Array();
   var store = new Ext.data.ArrayStore({
            fields: ['data', 'time'],
            data: dataArr
   });



   var varNodeId = '';//节点的id值
   var taskStart = false;
   //定时器里面的参数配置
   var task = {
            run: function(){
               gridStore.load({
                   params: {
                   'nodeid' : varNodeId,
                   'tem'    :th
                   },
                   callback:function(r){
                       if(!(typeof(r[0])==='undefined')) {
                       dataArr.push([r[0].data.data, r[0].data.time]);
                       store.loadData(dataArr);
                       }
                   }
               });
            },
            interval: 3000
   };

   var gridStore= new Ext.data.JsonStore({
        fields:['time', 'data'],
        autoLoad:true,
         baseParams : {
           'nodeid' : "",
           'tem'    :""
       },
        url :path+'/wenshi/getShishiData',
        root : "data"
    });
   var panel1= new Ext.Panel({
        title: '实时曲线图显示',
        width: 700,
        height: 400,
        smooth: true,
        type: 'circle',
        items: {
            xtype: 'linechart',
            url: 'extjs3/resources/charts.swf',
            store: store,
            xField: 'time',
            yField: 'data',
            xAxis: new Ext.chart.CategoryAxis({
                title: '时间(秒)'//00 09:00 分钟秒：毫秒
            }),
            yAxis: new Ext.chart.NumericAxis({
                title: '数值'
            })
        },
               tbar : [
                       {
                           xtype   : 'label',
                           text   : '请选择节点: '
                       },
                   node, {
                       xtype   : 'label',
                       text   : '请选择温湿度: '
                   },
                   temhum,
                {
                   text   : '查询',
                   handler   : function(btn, event) {
                           var nodeid = node.getValue();
                           var tem = temhum.getValue();
                           if (nodeid == undefined || nodeid == ''||tem==''){
                               return;
                           } else {
                               dataArr = new Array();
                               varNodeId = nodeid;
                               th = tem;
                           //   alert(th);
                               if(!taskStart) {
                                   Ext.TaskMgr.start(task);//定时执行代码
                                   taskStart =true;
                               }
                           }
                   }
               }]
    });
   Ext.ux.EmRealtimeDisplayPanel.superclass.constructor.call(this, {
       id : this.panelId,
       title : this.treeNode.text,
       layout       : 'fit',
       closable : true,
       preventBodyReset : true,
       items : [panel1]
   });

};
Ext.extend(Ext.ux.EmRealtimeDisplayPanel, Ext.Panel, {});

Ext.reg('emEmRealtimeDisplayPanel', Ext.ux.EmRealtimeDisplayPanel);

extjs和highcharts整合显示数据曲线和打印图片

Ext.namespace('Ext.ux');

Ext.ux.WaterRealtimeDisplayPanel = function(treeNode, panelId, config) {
 this.treeNode = treeNode;
 this.panelId = panelId;
 var series=[{"name":"实时数据显示","data":[]}];

 var temhum = new Ext.form.ComboBox({
 name : 'temhunm',
 fieldLabel : '状态',
 allowBlank : false,
 blankText : '请选择温湿度',
 editable : false,
 triggerAction : 'all',//all表示把下拉框列表框的列表值全部显示出来
 store : new Ext.data.ArrayStore({
 fields : [ 'name', 'value' ],
 data : [ [ '温度', '1' ], [ '湿度', '2' ] ]
 }),
 mode : 'local',
 displayField : 'name',
 valueField : 'value',
 width : 60
 });
 var storeProvince = new Ext.data.JsonStore({
 autoLoad:true,
 url : path+"/wenshi/getnode",
 root : "options",
 fields : [ {
 name : 'name'
 }]
 });
 var nodeCtl = new Ext.form.ComboBox({
 fieldLabel : '节点',
 allowBlank : false,
 blankText : '请选择节点',
 editable : false,
 triggerAction : 'all',
 store : storeProvince,
 mode : 'local',
 displayField : 'name',
 valueField : 'name',
 width : 140
 });
 var stTime = new Ext.form.DateField({
 fieldLabel : '选择时间',
 allowBlank : false,
 emptyText : '请选择开始日期',
 editable : false,
 format : 'Y-m-d',
 maxValue : new Date(),
 width : 130
 });
 var data = [
 ['y','年'],
 ['m','月'],
 ['d','日']
 // ['w','周']
 ];

 var store = new Ext.data.SimpleStore({
 fields: ['value', 'text'],
 data: data
 });
 var combo = new Ext.form.ComboBox({
 store: store,
 fieldLabel:"请选择时间对应的类型",
 emptyText: '请选择筛选类型',
 mode: 'local',
 triggerAction : 'all',
 valueField: 'value',
 displayField: 'text'
 });
 Ext.ux.WaterRealtimeDisplayPanel.superclass.constructor.call(this, {
 id : this.panelId,
 title : this.treeNode.text,
 closable : true,
 autoScroll : true,
 height : 400,
 items:[
 {
 layout:'column',
 border:false,
 items:[{
 //columnWidth: .25 ,
 layout:'form',
 border:false,
 labelAlign:'right',
 width : 200,
 labelWidth:40,
 items:[
temhum, nodeCtl]
 }
 ,{
 layout:'form',
 width : 200,
 labelWidth:60,
 border:false,
 labelAlign:'left',
 items:[stTime]
 },//combo
 combo
 ,
 {
 layout:'form',
 border:false,
 scope:this,
 items:[{
 xtype:'button',
 border:false,
 width:70,
 style:"margin-left:10px",
 text:'查询',
 scope:this,
 handler:function(){

 // 获取表单对象
 var _params_ = this.getForm().getValues(false);
 var nodeid = nodeCtl.getValue();//获取节点id
 var checktype=combo.getValue();//选择的筛选类型
 var checktime=stTime.getValue();//获取时间的值
 var th = temhum.getValue();
 if (th == undefined || th == ''){
 Ext.Msg.alert("提示","节点不能为空");
 return;
 }
 if (nodeid == undefined || nodeid == ''){
 Ext.Msg.alert("提示","节点不能为空");
 return;
 }
 if(!stTime.isValid()){
 Ext.Msg.alert('信息', '时间为必选项');
 return;
 }
 if (checktype == undefined || checktype == ''){
 Ext.Msg.alert("提示","筛选类型不能为空");
 return;
 }
 // 获得统计【就是显示的那个图】配置文件对象
 var _op_ = this.getOptions();

 //首先从后台获得x轴上值
 var categories=_op_.xAxis.categories;
 categories=[];
 $.ajax({
 type:"POST", // 提交方式
 url:path+'/wenshi/collectHositoryDataName', // 提交地址
 dataType:"json", // 解释格式
 data:{"nodeid":nodeid,"checktime":checktime.format('Y-m-d'),"checktype":checktype,"th":th}, // 请求参数
 success:function(iJson){
 var results = eval(iJson); // 转换成 JSON 数据
 var r = results[0].data;
 for(var i=0;i categories.push(r[i]);
 }

 _op_.xAxis.categories=categories;
 },
 error:function(){
 Ext.Msg.alert('系统操作','网络不通畅或数据格式不对！');
 }
 });

 // 获得统计对象的数据
 var _series_ = _op_.series;
 // 清空统计对象的数据重新加载
 _series_ = [] ;
 // 创建一个统计对象胡方法
 var _createChart_ = function (obj){new Highcharts.Chart(obj);};
 // 向后台发送请求
 var d = new Ext.util.DelayedTask(function(){
 $.ajax({
 type:"POST", // 提交方式
 url:path+'/wenshi/collectHositoryData', // 提交地址
 dataType:"json", // 解释格式
 data:{"nodeid":nodeid,"checktime":checktime.format('Y-m-d'),"checktype":checktype,"th":th}, // 请求参数
 success:function(iJson){
 var results = eval(iJson); // 转换成 JSON 数据
 for(var i =0 ; i < results.length;i++){ // 解释和装载数据
 _series_.push({name:results[i].name,data:results[i].data});
 }
 _op_.series = _series_; // 赋值
 _createChart_(_op_); // 重新创建一个统计
 },
 error:function(){
 Ext.Msg.alert('系统操作','网络不通畅或数据格式不对！');
 }
 });
 });
 d.delay(1000);
 }
 }]
 }]
 },
 {
 xtype:'panel', // 创建 Highcharts 所依赖的 div
 html:'

'
            }
                   ],
               listeners : {
                   activate : function(p) {
                          var obj=this.getOptions();
                          obj.series=series;
                          var chart =new Highcharts.Chart(obj);
                   }
               },
               getOptions:function(){
                   return     {
                                   chart : {
                                       renderTo :"test",
                                          type: 'spline'
                                   },
                                   lang : {
                                       exportButtonTitle : '导出图表',
                                       printButtonTitle : '打印报表'
                                   },
                                   title : {
                                       text : '节点历史参数曲线图'
                                   },
                                   xAxis : {
                                       title : {
                                           text : '采集时间'
                                       }
                                       ,
                                       //categories : ['1秒', '2秒','3秒']//设置x轴上分类名称
                                   },
                                   yAxis : {
                                       title : {
                                           text : '节点参数值'
                                       },
                                       plotLines: [{
                                              value: 0,
                                              width: 1,
                                              color: '#808080'
                                             }]
                                   },
                                   tooltip: {
                                                //enabled: false, //是否显示提示框
                                                formatter: function() {
                                                        return "时间:"+this.x +'
'+"参数值:"+ this.y;
                                                }
                                          }
                                   //,
//                                   series : [{
//                                               name : '实时数据显示',
//                                               data : [141, 100, 4]
//                                           }]
                               };
               }
           });
};
Ext.extend(Ext.ux.WaterRealtimeDisplayPanel, Ext.FormPanel, {
});
Ext.reg('ljsStudentTuPanel', Ext.ux.WaterRealtimeDisplayPanel);

后台导出图片的方法是：

public class ImageController extends Controller{

   public void index(){

       String type = getPara("type");
       String svg =getPara("svg");
       String filename = getPara("filename");
       ServletOutputStream out1 = null;
       try {
           filename = filename==null?"chart":filename;
           out1 = getResponse().getOutputStream();
           if (null != type && null != svg) {
                svg = svg.replaceAll(":rect", "rect");
                String ext = "";
                Transcoder t = null;
                if (type.equals("image/png")) {
                   ext = "png";
                   t = new PNGTranscoder();
                } else if (type.equals("image/jpeg")) {
                   ext = "jpg";
                   t = new JPEGTranscoder();
                } else if(type.equals("image/svg+xml")) {
                      ext = "svg";
                }else if(type.equals("application/pdf")){
                   t = new PDFTranscoder();
                   ext = "pdf";
                }

                getResponse().addHeader("Content-Disposition", "attachment; filename="+ filename + "."+ext);
                getResponse().addHeader("Content-Type", type);

                if (null != t) {
                   TranscoderInput input = new TranscoderInput(new StringReader(svg));
                   TranscoderOutput output = new TranscoderOutput(out1);
                   try {
                        t.transcode(input, output);
                   } catch (TranscoderException e) {
                        out1.print("Problem transcoding stream. See the web logs for more details.");
                        e.printStackTrace();
                   }
                } else if (ext.equals("svg")) {
                   OutputStreamWriter writer = new OutputStreamWriter(out1, "UTF-8");
                   writer.append(svg);
                   writer.flush();
                   writer.close();
                } else
                   out1.print("Invalid type: " + type);
           } else {
               //getResponse().addHeader("Content-Type", "text/html");
               // out.println("Usage:\n\tParameter [svg]: The DOM Element to be converted." +
               //        "\n\tParameter [type]: The destination MIME type for the elment to be transcoded.");
           }

       } catch (Exception e) {
           e.printStackTrace();
       }finally{
           try {
               out1.flush();
               getResponse().flushBuffer();
               out1.close();

           } catch (Exception e2) {

           }

       }

       renderNull();//不跳转



       }
}

java由年份和月份得到这个月有多少天

public static int getDaysByMonth(String time){
       Calendar rightNow = Calendar.getInstance();

       SimpleDateFormat simpleDate = new SimpleDateFormat("yyyy-MM"); //如果写成年月日的形式的话，要写小d，如："yyyy/MM/dd"

       try {

       rightNow.setTime(simpleDate.parse(time)); //要计算你想要的月份，改变这里即可

       } catch (Exception e) {

       e.printStackTrace();

       }

       int days = rightNow.getActualMaximum(Calendar.DAY_OF_MONTH);
return days;

   }

   public static List getWeekDay(String str) {
       List list = new ArrayList();
       Calendar c = Calendar.getInstance();
           SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
           Date date = null;
       try {
           date = sdf.parse(str);
       } catch (ParseException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
           c.setTime(date);
           int week = c.get(Calendar.WEEK_OF_MONTH);//获取是本月的第几周
           System.out.println("今天是本月的第" + week + "周");
           String nReturn;
           switch (c.get(Calendar.DAY_OF_WEEK)) {
           case 1:
               nReturn = "7";
               break;
           case 2:
               nReturn = "1";
               break;
           case 3:
               nReturn = "2";
               break;
           case 4:
               nReturn = "3";
               break;
           case 5:
               nReturn = "4";
               break;
           case 6:
               nReturn = "5";
               break;
           case 7:
               nReturn = "6";
               break;
           default:
               nReturn = null;
               break;
           }
           list.add(String.valueOf(String.valueOf(week)));
           list.add(nReturn);
           System.out.println(nReturn);
           return list;
       }

取得今天的星期几java

public static String getWeekOfDate(Date dt) {
        String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        Calendar cal = Calendar.getInstance();
        cal.setTime(dt);

int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
 if (w < 0)
 w = 0;

return weekDays[w];
}

setInterval和setTimeout的区别

这两个方法都可以用来实现在一个固定时间段之后去执行JavaScript。不过两者各有各的应用场景。

方法

实际上，setTimeout和setInterval的语法相同。它们都有两个参数，一个是将要执行的代码字符串，还有一个是以毫秒为单位的时间间隔，当过了那个时间段之后就将执行那段代码。

不过这两个函数还是有区别的，setInterval在执行完一次代码之后，经过了那个固定的时间间隔，它还会自动重复执行代码，而setTimeout只执行一次那段代码。

虽然表面上看来setTimeout只能应用在on-off方式的动作上，不过可以通过创建一个函数循环重复调用setTimeout，以实现重复的操作：

showTime();

function showTime()

{

var today = new Date();

alert("The time is: " + today.toString());

setTimeout("showTime()", 5000);

}
一旦调用了这个函数，那么就会每隔5秒钟就显示一次时间。如果使用setInterval，则相应的代码如下所示：

setInterval("showTime()", 5000);

function showTime()

{

var today = new Date();

alert("The time is: " + today.toString());

}

这两种方法可能看起来非常像，而且显示的结果也会很相似，不过两者的最大区别就是，setTimeout方法不会每隔5秒钟就执行一次showTime函数，它是在每次调用setTimeout后过5秒钟再去执行showTime函数。这意味着如果showTime函数的主体部分需要2秒钟执行完，那么整个函数则要每7秒钟才执行一次。而setInterval却没有被自己所调用的函数所束缚，它只是简单地每隔一定时间就重复执行一次那个函数。

如果要求在每隔一个固定的时间间隔后就精确地执行某动作，那么最好使用setInterval，而如果不想由于连续调用产生互相干扰的问题，尤其是每次函数的调用需要繁重的计算以及很长的处理时间，那么最好使用setTimeout。

两个计时函数中的第一个参数是一段代码的字符串，其实该参数也可以是一个函数指针，不过Mac下的IE 5对此不支持。

如果用函数指针作为setTimeout和setInterval函数的第二个参数，那么它们就可以去执行一个在别处定义的函数了：

setTimeout(showTime, 500);

function showTime()

{

var today = new Date();

alert("The time is: " + today.toString());

}

另外，匿名函数还可以声明为内联函数：

setTimeout(function(){var today = new Date();

alert("The time is: " + today.toString());}, 500);

如果对计时函数不加以处理，那么setInterval将会持续执行相同的代码，一直到浏览器窗口关闭，或者用户转到了另外一个页面为止。不过还是有办法可以终止setTimeout和setInterval函数的执行。

当setInterval调用执行完毕时，它将返回一个timer ID，将来便可以利用该值对计时器进行访问，如果将该ID传递给clearInterval，便可以终止那段被调用的过程代码的执行了，具体实现如下：

var intervalProcess = setInterval("alert('GOAL!')", 3000);

var stopGoalLink = document.getElementById("stopGoalLink");

attachEventListener(stopGoalLink, "click", stopGoal, false);

function stopGoal()

{

clearInterval(intervalProcess);

}

只要点击了stopGoalLink，不管是什么时候点击，intervalProcess都会被取消掉，以后都不会再继续反复执行intervalProcess。如果在超时时间段内就取消setTimeout，那么这种终止效果也可以在setTimeout身上实现，具体实现如下：

var timeoutProcess = setTimeout("alert('GOAL!')", 3000);

var stopGoalLink = document.getElementById("stopGoalLink");

attachEventListener(stopGoalLink, "click", stopGoal, false);

function stopGoal()

{

clearTimeout(timeoutProcess);

}

jquery隐藏和显示的切换

佳能(30440)

索尼(27220)

三星(20808)

尼康(17821)

松下(12289)

卡西欧(8242)

富士(14894)

柯达(9520)

宾得(2195)

理光(4114)

奥林巴斯(12205)

明基(1466)

爱国者(3091)

其它品牌相机(7275)

显示全部品牌

jquery笔记

javascript点击触发事件

点击我.

jquery点击触发事件

jQuery Demo

javascript获得元素改变css

test

jquery得到元素改变css

test

javascript多选的得到值

jquery隔行换色

第一行	第一行
第二行	第二行
第三行	第三行
第四行	第四行
第五行	第五行
第六行	第六行

javascript隔行换色

第一行	第一行
第二行	第二行
第三行	第三行
第四行	第四行
第五行	第五行
第六行	第六行

jquery得到checkbox值

$('ul li:gt(5):not(:last)') :
选取ul元素下的li元素的索引值大于5的集合元素后，去掉集合元素中的最后一个。
索引值从0开始。

checkbox使用javascript和jquery两种方式选择

DOM方式

1-6-2

我已经阅读了上面制度.

jQuery方式

1-6-1

我已经阅读了上面制度.

折叠隐藏导航栏jquery

1-5-1

javascript笔记

1-4

例子

摘要: //定义一个对象 var obj = new Object(); //动态创建属性name obj.name = "an object"; //动态创建属性sayHi obj.sayHi = function(){ return "Hi";... 阅读全文

java程序性能优化2

HaspMap的遍历。 Map paraMap = new HashMap(); for( Entry entry : paraMap.entrySet() )

{ String appFieldDefId = entry.getKey(); String[] values = entry.getValue(); }

利用散列值取出相应的Entry做比较得到结果，取得entry的值之后直接取key和 value。

奇偶判断不要使用 i % 2 == 1 来判断是否是奇数，因为i为负奇数时不成立，请使用 i % 2 != 0 来判断是否是奇数，或使用高效式 (i & 1) != 0来判断。

java程序性能优化3

六、避免不需要的instanceof操作如果左边的对象的静态类型等于右边的，instanceof表达式返回永远为true。例子： public class uiso { public uiso () {} } class dog extends uiso { void method (dog dog, uiso u) { dog d = dog;if (d instanceof uiso) // always true. system.out.println("dog is a uiso"); uiso uiso = u; if (uiso instanceof object) // always true. system.out.println("uiso is an object"); } } 更正：删掉不需要的instanceof操作。 class dog extends uiso { void method () { dog d; system.out.println ("dog is an uiso"); system.out.println ("uiso is an uiso"); } }

七、避免不需要的造型操作所有的类都是直接或者间接继承自object。同样，所有的子类也都隐含的“等于”其父类。那么，由子类造型至父类的操作就是不必要的了。例子： class unc { string _id = "unc"; } class dog extends unc { void method () { dog dog = new dog (); unc animal = (unc)dog; // not necessary. object o = (object)dog; // not necessary. } } 更正： class dog extends unc { void method () { dog dog = new dog(); unc animal = dog; object o = dog; } }

八、如果只是查找单个字符的话，用charat()代替startswith()

用一个字符作为参数调用startswith()也会工作的很好，但从性能角度上来看，调用用string api无疑是错误的! 例子： public class pcts { private void method(string s) { if (s.startswith("a")) { // violation // ... } } } 更正将'startswith()' 替换成'charat()'. public class pcts { private void method(string s) { if ('a' == s.charat(0)) { // ... } } }

九、使用移位操作来代替'a / b'操作 "/"是一个很“昂贵”的操作，使用移位操作将会更快更有效。例子： public class sdiv { public static final int num = 16; public void calculate(int a) { int div = a / 4; // should be replaced with "a >> 2". int div2 = a / 8; // should be replaced with "a >> 3". int temp = a / 3; } } 更正： public class sdiv { public static final int num = 16; public void calculate(int a) { int div = a >> 2; int div2 = a >> 3; int temp = a / 3; // 不能转换成位移操作 } }

十、使用移位操作代替'a * b'

同上。 [i]但我个人认为，除非是在一个非常大的循环内，性能非常重要，而且你很清楚你自己在做什么，方可使用这种方法。否则提高性能所带来的程序晚读性的降低将是不合算的。例子： public class smul { public void calculate(int a) { int mul = a * 4; // should be replaced with "a << 2". int mul2 = 8 * a; // should be replaced with "a << 3". int temp = a * 3; } } 更正： package opt; public class smul { public void calculate(int a) { int mul = a << 2; int mul2 = a << 3; int temp = a * 3; // 不能转换 } }

十一、在字符串相加的时候，使用 ' ' 代替 " "，如果该字符串只有一个字符的话例子： public class str { public void method(string s) { string string = s + "d" // violation. string = "abc" + "d" // violation. } } 更正：将一个字符的字符串替换成' ' public class str { public void method(string s) { string string = s + 'd' string = "abc" + 'd' } }

十二、将try/catch块移出循环把try/catch块放入循环体内，会极大的影响性能，如果编译jit被关闭或者你所使用的是一个不带jit的jvm，性能会将下降21%之多! 例子： import java.io.fileinputstream; public class try { void method (fileinputstream fis) { for (int i = 0; i < size; i++) { try { // violation _sum += fis.read(); } catch (exception e) {} } } private int _sum; } 更正：将try/catch块移出循环 void method (fileinputstream fis) { try { for (int i = 0; i < size; i++) {

_sum += fis.read(); } } catch (exception e) {} }

十三、对于boolean值，避免不必要的等式判断将一个boolean值与一个true比较是一个恒等操作(直接返回该boolean变量的值). 移走对于boolean的不必要操作至少会带来2个好处： 1)代码执行的更快 (生成的字节码少了5个字节)； 2)代码也会更加干净。例子： public class ueq { boolean method (string string) { return string.endswith ("a") == true; // violation } } 更正： class ueq_fixed { boolean method (string string) { return string.endswith ("a"); } }

十四、对于常量字符串，用'string' 代替 'stringbuffer' 常量字符串并不需要动态改变长度。例子： public class usc { string method () { stringbuffer s = new stringbuffer ("hello"); string t = s + "world!"; return t; } } 更正：把stringbuffer换成string，如果确定这个string不会再变的话，这将会减少运行开销提高性能。

十五、使用条件操作符替代"if (cond) return; else return;" 结构条件操作符更加的简捷例子： public class if { public int method(boolean isdone) { if (isdone) { return 0; } else { return 10; } } } 更正： public class if { public int method(boolean isdone) { return (isdone ? 0 : 10); } }

十六、不要在循环体中实例化变量在循环体中实例化临时变量将会增加内存消耗例子： import java.util.vector; public class loop { void method (vector v) { for (int i=0;i < v.size();i++) { object o = new object(); o = v.elementat(i); } } } 更正：在循环体外定义变量，并反复使用 import java.util.vector; public class loop { void method (vector v) { object o; for (int i=0;i

java程序性能优化4

一、避免在循环条件中使用复杂表达式在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。例子： import java.util.vector; class cel { void method (vector vector) { for (int i = 0; i < vector.size (); i++) // violation ; // } } 更正： class cel_fixed { void method (vector vector) { int size = vector.size () for (int i = 0; i < size; i++) ; // } }

二、为'vectors' 和 'hashtables'定义初始大小 jvm为vector扩充大小的时候需要重新创建一个更大的数组，将原原先数组中的内容复制过来，最后，原先的数组再被回收。可见vector容量的扩大是一个颇费时间的事。通常，默认的10个元素大小是不够的。你最好能准确的估计你所需要的最佳大小。例子： import java.util.vector;
public class dic { public void addobjects (object[] o) { // if length > 10, vector needs to expand for (int i = 0; i< o.length;i++) { v.add(o); // capacity before it can add more elements. } } public vector v = new vector(); // no initialcapacity. } 更正：自己设定初始大小。 public vector v = new vector(20); public hashtable hash = new hashtable(10);

三、在finally块中关闭stream 程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。例子： import java.io.*; public class cs { public static void main (string args[]) { cs cs = new cs (); cs.method (); } public void method () { try { fileinputstream fis = new fileinputstream ("cs.java"); int count = 0; while (fis.read () != -1) count++; system.out.println (count); fis.close (); } catch (filenotfoundexception e1) { } catch (ioexception e2) { } } } 更正：在最后一个catch后添加一个finally块

四、使用'system.arraycopy ()'代替通过来循环复制数组 'system.arraycopy ()' 要比通过循环来复制数组快的多。例子： public class irb { void method () { int[] array1 = new int [100]; for (int i = 0; i < array1.length; i++) { array1 [i] = i; } int[] array2 = new int [100]; for (int i = 0; i < array2.length; i++) { array2 [i] = array1 [i]; // violation } } } 更正： public class irb{ void method () { int[] array1 = new int [100]; for (int i = 0; i < array1.length; i++) { array1 [i] = i; } int[] array2 = new int [100]; system.arraycopy(array1, 0, array2, 0, 100); } }

五、让访问实例内变量的getter/setter方法变成”final” 简单的getter/setter方法应该被置成final，这会告诉编译器，这个方法不会被重载，所以，可以变成”inlined” 例子： class maf { public void setsize (int size) { _size = size; } private int _size; } 更正： class daf_fixed { final public void setsize (int size) { _size = size; } private int _size; }

checkbox选择

js获取单选框、复选框的值及操作

前天

昨天

今天

明天

后天

前年

去年

今年

明年

后年

ext向后台传隐藏的id值

var stroeName = new Ext.data.JsonStore({
       autoLoad : true,
       url : "BookAction_getName.action",
       root : "options",
       fields : [
                  'name','id'
                  ]

   });


   var state = new Ext.form.ComboBox({
       name : 'name',
       fieldLabel : '图书名',
       allowBlank : false,
       blankText : '请选择',
       emptyText : '请选择',
       editable : false,
       triggerAction : 'all',
       store : stroeName,
       //加载本地数据框
       mode : 'local',
       displayField : 'name',
       valueField : 'id',
       hiddenName :'id',
       //hiddenName :'id',
       width : 125
   });

Niagara采集温湿度和控制灯的亮灭

1.在采集温湿度数据时，现在config下建立温湿度的文件夹（view），

2.在此文件夹下新建立NumericWritable的wen节点，在view中建立kitPx中的Bargraph柱状图，编辑对应wen节点中out中的value，

3.在控制灯的开关时在kitPx中选择ActionButton，为每个灯选择2个ActionButton，一个开，一个关，编辑开的开关选择此灯节点中的emergencyActive，编辑关的开关选择此灯节点中的emergencyInactive，

4.在Palette中找iopt,找host,,在config下建立iopt文件夹，Local Port设置6800，Dest Port设置1025

Niagara新建station灯光报警

1.在tools中选择new station，新建一个station

2.点击Platform启动新建的station

3.在File中选择open station（fox）点击

4.选择station中的Config右键新建文件夹（如yang）

5.在此文件夹下右键新疆Wire Sheet

6.在Wire Sheet下右键选择new 一个numericWritable

7.在这个numericWritable右键action中set数值

8.重复6.7再次建立一个标准值的numericWritable

9.在Wire Sheet下右键选择new 一个BooleanWritable

10.在这个BooleanWritable右键action中setboolean值

11.在Window中的Side Bars中点击Palette

12.在Palette中找到kitControl中的Logic中的GreaterThan拖入到Wire Sheet中

13.让两个的numericWritable的Out分别指向GreaterThan的A和B（A>B是true）

14.再让GreaterThan的Out指向BooleanWritable其中一个值

15.在yang文件夹右键点击Views中的New View

16.在kitPx中把AnalogMeter拖入New View，再双击New View选择ord

在ord的弹出框中的下箭头选择Component Chooser,,选择yang文件夹中的一个值（不是标准值）

17.在KitPxHvac中的boolean中的bulb，拖入New View，再双击New View选择ord

在ord的弹出框中的下箭头选择Component Chooser,,选择yang文件夹中的boolean对象。

jfinal源码学习

当用户访问系统时，所有请求先进过在web.xml中配置的com.jfinal.core.JFinalFilter这个核心类，
先执行这个类的的init方法，实例化jfinalConfig对象，这个对象是需要开发者自己定义一个类继承

JFinalConfig类，实现几个抽象方法，其中public void configConstant(Constants me)方法是配置数据库的信息，
开发模式，视图的类型等，public void configRoute(Routes me)方法是配置访问路径的路由信息，

public void configPlugin(Plugins me) 方法是配置数据库连接，其他一些插件，对象模型， public void configInterceptor(Interceptors me)方法是配置全局拦截器，public void configHandler(Handlers me)

是配置处理器，此方法会得到访问的url，进行处理。此类需要在web.xml中配置，如下：

jfinal

com.jfinal.core.JFinalFilter

configClass

com.demo.config.DemoConfig

jfinal

在JFinalFilter类中当执行完init方法后，会执行jfinal类的init方法，此方法是先定义得到工程的路径，再初始化开发者刚刚写的

继承JFinalConfig类的类，读入配置信息。当init方法执行完后，执行doFilter方法，得到用户访问的url，分到不同的handler中进行处理

java时间程序

摘要: import java.util.*;002import java.text.*;003import java.util.Calendar;004public class VeDate {005 /**006 * 获取现在时间007 * 008 * 多个有用的程序

摘要: 1. 字符串有整型的相互转换 1 2 String a = String.valueOf(2); //integer to numeric string 3 int i = Integer.parseInt(a); //numeric string to an int ... 阅读全文

svn使用

摘要: 1.svn环境搭建在应用myEclips 8.5做项目时，svn会成为团队项目的一个非常好的工具，苦苦在网上寻求了一下午，终于整合好了这个环境，在这里简单介绍下，希望能为刚开始用svn的朋友一点点帮助。 svn环境需要（1）服务器端（2）客户端（3）应用在myeclipse中的svn插件第一步，安装svn服务器端。我用的是VisualSVN-Server-2.1.3这... 阅读全文

myeclipse自动提示配置

1. 打开MyEclipse，然后 Window-------->Preferences;

2.选择Java-------->展开-------->Editor-------->选择ContentAssist;

3.选择ContentAssist-------->然后看到右边-------->右边的Auto-Activation下面的Auto Activation triggers for java（指触发代码提示的就是”.”这个符号）这个选项;

4. AutoActivation triggers for java这个选项-------->在”.”后加

abcdefghijklmnopqrstuvwxyz

字母，方便后面的查找修改-------->然后apply-------->点击OK;

struts2标签

摘要: Struts2 Taglib抽象了不同表示技术，现在Struts2主要支持三种表示技术：JSP,FreeMarker和Velocity。但部分的Tag在三种表示技术下都可以使用，但是也有部分只能在某一种情况下使用。 Tab可以分为两类：通用标签和UI标签。 4.1节通用标签通用标签用来在页面表示的时候控制代码执行的过程，这些标签也允许从Action或者值堆栈中取得数据。例如地域，JavaBea... 阅读全文

tomcat中配置数据库连接池

4.1连接池知识简介

众所周知建立数据库连接是一个非常耗时耗资源的行为，因此现代的Web中间件，无论是开源的Tomcat、Jboss还是商业的 websphere、weblogic都提供了数据库连接池功能，可以毫不夸张的说，数据库连接池性能的好坏，不同厂商对连接池有着不同的实现，本文只介绍拜特公司使用较多的开源web中间件Tomcat中默认的连接池DBCP（DataBase connection pool）的使用。

4.2 Tomcat下配置连接池

下面以tomcat5.5.26为例来介绍如何配置连接池

1：需要的jar

在tomcat的安装目录common\lib下有一个naming-factory-dbcp.jar，这个是tomcat修改后的dbcp连接池实现，同时为了能够正常运行，还需要commons-pool.jar。

2：建立context文件

进入到conf\Catalina\localhost新建一个上下文文件，文件的名称既为将来要访问是输入url上下文名称，例如我们建立一个名为btweb的文件内容如下：

name="jdbc/btdb1"

type="javax.sql.DataSource"

factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"

username="v10"

password="v10"

driverClassName="oracle.jdbc.driver.OracleDriver"

url="jdbc:oracle:thin:@127.0.0.1:1521:cahs"

maxActive="5"

maxIdle="3"

maxWait="5000"

removeAbandoned="true"

removeAbandonedTimeout="60"

testOnBorrow="true"

validationQuery="selectcount(*) from bt_user"

logAbandoned="true"

4.3参数分步介绍

u 数据库连接相关

username="v10"

password="v10"

driverClassName="oracle.jdbc.driver.OracleDriver"

url="jdbc:oracle:thin:@127.0.0.1:1521:cahs"

u jndi相关

name="jdbc/btdb1"

type="javax.sql.DataSource"

factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"

factory默认是org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory，tomcat也允许采用其他连接实现，不过默认使用dbcp。

u 连接数控制与连接归还策略

maxActive="5"

maxIdle="3"

minIdle=”2”

maxWait="5000"

u 应对网络不稳定的策略

testOnBorrow="true"

validationQuery="selectcount(*) from bt_user"

u 应对连接泄漏的策略

removeAbandoned="true"

removeAbandonedTimeout="60"

logAbandoned="true"

如下图所示：连接池处于应用程序与数据库之间，一方面应用程序通过它来获取连接，归还连接，另一方面连接又需要从数据里获取连接，归还连接。

步骤1：系统启动

系统启动时，初始化连接池，由于没有任何请求连接池中连接数为0。

maxActive="5"

表示并发情况下最大可从连接池中获取的连接数。如果数据库不是单独，供一个应用使用，通过设置maxActive参数可以避免某个应用无限制的获取连接对其他应用造成影响，如果一个数据库只是用来支持一个应用那么maxActive理论上可以设置成该数据库可以支撑的最大连接数。maxActive 只是表示通过连接池可以并发的获取的最大连接数。

从图上我们可以看到连接的获取与释放是双向，当应用程序并发请求连接池时，连接池就需要从数据库获取连接，那么但应用程序使用完连接并将连接归还给连接池时，连接池是否也同时将连接归还给数据库呢？很显然答案是否定的，如果那样的话连接池就变得多此一举，不但不能提高性能，反而会降低性能，那么但应用成归还连接后，连接池如何处理呢？

maxIdle="3"

如果在并发时达到了maxActive=5，那么连接池就必须从数据库中获取5个连接来供应用程序使用，当应用程序关闭连接后，由于maxIdle=3,因此并不是所有的连接都会归还给数据库，将会有3个连接保持在连接池种中，状态为空闲。

minIdle=”2”

最小默认情况下并不生效，它的含义是当连接池中的连接少有minIdle，系统监控线程将启动补充功能，一般情况下我们并不启动补充线程。

问题：如何设置maxActive和maxIdle？

理论上讲maxActive应该设置成应用的最大并发数，这样一来即便是在最大并发的情况下，应用依然能够从连接池中获取连接，但是困难时的是我们很难准确估计到最大并发数，设置成最大并发数是一种最优的服务质量保证，事实上，如果某个用户登录提示系统繁忙，那么在他再次登录时，可能系统资源已经充足，对于拜特资金管理系统我们建议将maxActive设置为系统注册人数的十分之一到二十分之一之间。例如系统的注册人数为1000，那么设置成50-100靠近100的数字，例如85或90。

maxIdle对应的连接，实际上是连接池保持的长连接，这也是连接池发挥优势的部分，理论上讲保持较多的长连接，在应用请求时可以更快的响应，但是过多的连接保持，反而会消耗数据库大量的资源，因此maxIdle也并不是越大越好，同上例我们建议将maxIdle设置成

50-100中靠近50的数字，例如55。这样就能在兼顾最大并发同时，保持较少的数据库连接，而且在绝大多情况，能够为应用程序提供最快的相应速度。

testOnBorrow="true"

validationQuery="selectcount(*) from bt_user"

我们知道数据库连接从本质上架构在tcp/ip连接之上，一般情况下web服务器与数据库服务器都不在同一台物理机器上，而是通过网络进行连接，那么当建立数据库连接池的机器与数据库服务器自己出现网络异常时，保持在连接池中的连接将失效，不能够在次使用，传统的情况下只能通过重新启动，再次建立连接，通过设置以上两个参数，但应用程序从连接池中获取连接时，会首先进行活动性检测，当获取的连接是活动的时候才会给应用程序使用，如果连接失效，连接将释放该连接。validationQuery是一条测试语句，没有实际意义，现实中，一般用一条最为简单的查询语句充当。

removeAbandoned="true"

removeAbandonedTimeout="60"

logAbandoned="true"

有时粗心的程序编写者在从连接池中获取连接使用后忘记了连接的关闭，这样连池的连接就会逐渐达到maxActive直至连接池无法提供服务。现代连接池一般提供一种“智能”的检查，但设置了removeAbandoned="true"时，当连接池连接数到达(getNumIdle() < 2) and (getNumActive() > getMaxActive() - 3)时便会启动连接回收，那种活动时间超过removeAbandonedTimeout="60"的连接将会被回收，同时如果logAbandoned="true"设置为true,程序在回收连接的同时会打印日志。removeAbandoned是连接池的高级功能，理论上这中配置不应该出现在实际的生产环境，因为有时应用程序执行长事务，可能这种情况下，会被连接池误回收，该种配置一般在程序测试阶段，为了定位连接泄漏的具体代码位置，被开启，生产环境中连接的关闭应该靠程序自己保证。

strut2ognl

经过一段时间的闭关练习,终于对struts2有所了解.其实struts2并不难, 一看就能明白其中奥妙.我对struts2的验证体系保留怀疑态度,因为它的验证消息使用标签打在页面上,实在太丑,在真实项目中不知道是否有人这么做. 也许是我太菜了,还不知道如何将验证消息显示得更友好,希望各位不吝拍砖指导.
　　然而,我认为struts2最复杂难学的是它内置的ognl表达式.这个ognl在我开始学struts2时,让我云里雾里,不知如何应对.经过几轮的翻看书籍,与网上资料查询,还算是让我有所明白一点.在此记录,以便日后温习,同时,如果这篇文章对各位有哪怕一点帮助,那便是我最大的荣幸.
　　首先,要知道ognl最主要的功能就是取数据,它可以利用一段简短的表达式取出各种各样丰富的数据.其次,它还附带了一些便捷的功能,如:方法调用、静态方法和属性调用、数值运算……我们最关心的是如何取数据，因此，接下来我将重点介绍如何取数据，至于附带功能将不做介绍。
　　知道了ognl最主要的功能是取数据后，那么数据从哪里取呢！ognl会从两个地方取：一个是Action的实例属性；另一个是 ValueStack（中文名叫值栈）。ognl会先从前者里面取，如果没取到再到ValueStack里取。Action的实例属性好理解，但这个 ValueStack从字面上看，着实不好理解，以致于我将struts２的源码引进eclipse里，单步调试才算有所启发。可以将 ValueStack初步理解为一个map，在这个map里存储了request、session、application、response、 action实例、parameters数组……还有很多你不知道的对象。有了这个map，还愁数据取不到吗。
　　注意：将ValueStack初步理解为一个map，只适于初学struts2的人，其实它内部并没这么简单。由于水平、时间有限，我并不能掌握其内部精髓，加上表达能力不佳，怕表达不对误导大家，所以我们姑且理解ValueStack为一个map吧。如果想更深的了解的ValueStack，请查看 struts2的源码。

　　接下来，便是取数据。取action实例的属性数据与取ValueStack中的数据不一样，先说取action实例的属性数据吧。
　　action实例的属性数据可以直接在struts2的标签中通过属性名取到。如：、
　　注意：不要加#号。

再是取ValueStack中的数据。
　　struts２提供三种方式通过ognl表达式来取ValueStack中的数据：#、%{}、${}
　　#和%{}需要放到struts2提供的标签里才生效。如：、
　　一、最常用的方式是：#
　　１.#能取request、session、application里的attribute，但需要加前缀。如：、。如果是取request范围的attribute，那么不需要加request前缀，加上反而取不到数据，ognl默认从request里取，如果没有取到并不会到session或application里取。如：
　　２.#能取request里的请求参数，但必须加parameters前缀,且取到的是一个数组，所以如果你要得到参数的第一项值，那么还要加下标。如：。这相当于调用 request.getParameterValues("name")[0];
　　3.#加attr前缀能按request > session > application顺序获取attribute，这样当在request中取不到时，会自动向session里取，如果session里也取不到，会再向application里取。如果取到则返回，不再向上游历。如：
　　４.#能构造Map，如：
　　５.#能用于过滤和投影（projecting)集合，如：books.{?#this.price<100}
　　以上第４、５项功能，我没有做过多介绍，因为目前为止这两项功能我使用并不多。
　　二、%{}的用途是在标签的属性为字符串类型时，计算OGNL表达式的值。这个功能目前还没有深刻体会，故不介绍。
　　三、${}有两个主要的用途。
　　１.用于在国际化资源文件中，引用OGNL表达式。
　　２.在Struts 2配置文件中，引用OGNL表达式。如：
　　

 ListPhotos.action?albumId=${albumId}

　　以上，其实主要介绍了#的使用，大部分情况下我们只与它打交道，另外两种方式需要在以后的项目中多多使用才能有所体会。
　　其实，我是jstl+el的忠实粉丝，在任何项目中，只要能用上jstl标签的，我决不用其它标签。因为它是官方标准，还有它简单且已熟练，我已在众多项目中实战演练过，有了它们，我不想在使用其它标签。
　　说到了这里，我还是有必要再多说两句，是不是使用了struts2，就不能再用el来取数据了呢？答案是否定的，完全可以使用el来取数据。 struts2会将ValueStack里的session、application里的attribute完全复制到HttpSession、 ServletContext里，这样el表达式照样能取到这两个Scope里的数据。然而，struts2并没有将ValueStack里的 request里的attribute复制到HttpServletRequest，这是不是意味着el表达式就不能取request里的数据了呢？还是可以，不只可以取request里的数据，还可以取action实例的属性值。神奇吧！奥秘就在struts2对request做了封装，这个封装类是 org.apache.struts2.dispatcher.StrutsRequestWrapper，它重写了getAttribute()方法，该方法先从真实的request类里取attribute，如果取到则返回，如果没有取到则从ValueStack里取，现在明白了吧！

各种数据库默认端口

一：Oracle

驱动：oracle.jdbc.driver.OracleDriver
 URL：jdbc:oracle:thin:@<:port>:dbname
 注：machine_name：数据库所在的机器的名称，如果是本机则是127.0.0.1或者是localhost，如果是远程连接，则是远程的IP地址；

port：端口号，默认是1521

二：SQL Server

驱动：com.microsoft.jdbc.sqlserver.SQLServerDriver
 URL：jdbc:microsoft:sqlserver://<:port>;DatabaseName=
 注：machine_name：数据库所在的机器的名称，如果是本机则是127.0.0.1或者是localhost，如果是远程连接，则是远程的IP地址；
 port：端口号，默认是1433

三：MySQL

驱动：org.gjt.mm.mysql.Driver
 URL：jdbc:mysql://<:port>/dbname
 注：machine_name：数据库所在的机器的名称，如果是本机则是127.0.0.1或者是localhost，如果是远程连接，则是远程的IP地址；
 port：端口号，默认3306

四：pointbase

驱动：com.pointbase.jdbc.jdbcUniversalDriver
 URL：jdbc:pointbase:server://<:port>/dbname
 注：machine_name：数据库所在的机器的名称，如果是本机则是127.0.0.1或者是localhost，如果是远程连接，则是远程的IP地址；
 port：端口号，默认是9092

五：DB2

驱动：com.ibm.db2.jdbc.app.DB2Driver
 URL：jdbc:db2://<:port>/dbname
 注：machine_name：数据库所在的机器的名称，如果是本机则是127.0.0.1或者是localhost，如果是远程连接，则是远程的IP地址；
 port：端口号，默认是5000

js函数

一、function概述

javascript中的函数不同于其他的语言，每个函数都是作为一个对象被维护和运行的。通过函数对象的性质，可以很方便的将一个函数赋值给一个变量或者将函数作为参数传递。

函数对象与其他用户所定义的对象有着本质的区别，这一类对象被称之为内部对象。内置对象的构造器是由JavaScript本身所定义的。

二、function对象的创建

在JavaScript中，函数对象对应的类型是Function，可以通过new Function()来创建一个函数对象，也可以通过function关键字来创建一个对象。

//使用new Function()方式创建

var myFunction=new Function("a","b","return a+b");

//使用function关键字创建

function myFunction(a,b) {

return a + b;

}

用关键字创建对象的时候，在解释器内部，就会自动构造一个Function对象，将函数作为一个内部的对象来存储和运行。从这里也可以看到，一个函数对象名称（函数变量）和一个普通变量名称具有同样的规范，都可以通过变量名来引用这个变量，但是函数变量名后面可以跟上括号和参数列表来进行函数调用。

new Function()的语法规范如下：

var funcName=new Function(p1,p2,...,pn,body);

　　参数的类型都是字符串，p1到pn表示所创建函数的参数名称列表，body表示所创建函数的函数体语句，funcName就是所创建函数的名称。可以不指定任何参数创建一个空函数，不指定funcName创建一个匿名函数。

　　需要注意的是，p1到pn是参数名称的列表，即p1不仅能代表一个参数，它也可以是一个逗号隔开的参数列表，例如下面的定义是等价的：

　　new Function("a", "b", "c", "return a+b+c")

　　new Function("a, b, c", "return a+b+c")

　　new Function("a,b", "c", "return a+b+c")

函数的本质是一个内部对象，由JavaScript解释器决定其运行方式。并且可直接在函数声明后面加上括号就表示创建完成后立即进行函数调用，例如：

var i=function (a,b){

　　 return a+b;

　　}(1,2);

　　alert(i);

这段代码会显示变量i的值等于3。i是表示返回的值，而不是创建的函数，因为括号“(”比等号“=”有更高的优先级。

三、匿名函数和有名函数的区别

匿名函数必须先定义后调用，有名函数可以先调用，后定义。

A）匿名（这段语句将产生func未定义的错误）

如果要让上述代码的第一次调用输出“hello”，可以将它们分为两段：

下面的代码输出“hello”

下面的代码输出“yeah”

从上面对段的位置变化导致输出变化很清楚的解释了JS解释器分段分析执行的本质。

java文件上传下载

JAVA的文件上传遍一直是一个比较关注的问题,而且有几个NB东西提供了这个功能.

用的最多的算是三个(我就知道这三个)比较强的,一个是比较早的jspsmartupload,另一个是出身名族的commonupload,还有一个就是orellay的了.

我用的比较多是前两个,总的感觉是jspsmartuplod比较灵活,功能上更强一些(一点点吧),但是现在网上也不维护,也不能下载了,特别是它上传的时候把上传文件放到内存里,所以上传文件的大小会和内存有关系.commonupload虽然没有提供很多API,但是它有比较灵活,它上传的过程中会把上传的文件先写入磁盘,所以上传的大小只是带宽有关系,我尝试最大的上传文件的大小是700M,当然是本地测试:>

还有是就是在Linux/Unix系统上传文件的中文问题,我在下面的代码有了一些解决.

下面是前两种方式的上传代码:

try{
//取session 用户oid
int pid = userInfo.getUserId();
String sys_user_id = String.valueOf(pid);
//取init配置文件的参数值
String sitePhysicalPath = (String)init.getObject("SitePhysicalPath");
String saveDir = (String)init.getObject("InfoUploadDir");
String tempDir = (String)init.getObject("InfoUploadDir");
String fileMemo = ""; //文件说明
String fileName = null; //存储到数据库的文件名
String saveName = null; //存储到本地的文件名
String filePath = null; //存储到数据库的文件路径
String savePath = null; //存储到本地的文件路径
long fileSize = 0; //文件大小
int maxPostSize = -1;
int dinfo_upload_id = -1;
%>
<%
//初始化
mySmartUpload.initialize(pageContext);
//上载文件
mySmartUpload.upload();
//循环取得所有上载文件
for(int i=0; i {
//取得上载文件
com.jspsmart.upload.File file = mySmartUpload.getFiles().getFile(i);
if(!file.isMissing())
{
fileName = file.getFileName();
//取得文件扩展名file.getFileExt()
try{
saveName = fileName.substring(fileName.lastIndexOf("."));

}catch(Exception e){
saveName = "";
}
//取得文件大小
fileSize = file.getSize();
//存储路径
String sql_id = " SELECT S_INFO_UPLOAD.nextval as seqid FROM dual ";
try{
Statement stmt = con.createStatement();
ResultSet rst = stmt.executeQuery(sql_id);
while(rst.next())
{
dinfo_upload_id = rst.getInt("seqid");
}
}catch(SQLException sqle){
return;
}

filePath = sitePhysicalPath + saveDir + Integer.toString(dinfo_upload_id) + saveName;
savePath = saveDir + Integer.toString(dinfo_upload_id) + saveName;
//存储文件到本地
file.saveAs(filePath);
//存储文件到数据库
switch(i)
{
case 0: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo1"); break;
case 1: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo2"); break;
case 2: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo3"); break;
case 3: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo4"); break;
case 4: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo5"); break;
default: fileMemo = "";
}

String sql = " INSERT INTO info_upload (info_upload_id,sys_user_id,file_size,file_path,utime,deleted) "
+ " VALUES( " + Integer.toString(dinfo_upload_id) + "," + sys_user_id + "," + fileSize + ",'" + savePath + "', SYSDATE , 0 )" ;
sqlcmd cmd = new sqlcmd(con,sql);
//System.out.println(sql);
java.sql.PreparedStatement pstmt = null;
java.sql.Statement stmt = null;
//fileName = fileName.substring(0, fileName.indexOf("."));
String sql_cn = " UPDATE info_upload SET file_name=?,file_memo=? WHERE info_upload_id=? ";
java.io.ByteArrayInputStream bais_name = new java.io.ByteArrayInputStream(fileName.getBytes("ISO-8859-1"));
java.io.InputStreamReader isr_name = new java.io.InputStreamReader((InputStream)bais_name,"GBK");

java.io.ByteArrayInputStream bais_memo = new java.io.ByteArrayInputStream(fileMemo.getBytes("GBK"));
java.io.InputStreamReader isr_memo = new java.io.InputStreamReader((InputStream)bais_memo,"GBK");

try{
stmt = con.createStatement();
stmt.getConnection().setAutoCommit(false);

pstmt = con.prepareStatement(sql_cn);
pstmt.setCharacterStream(1, isr_name, fileName.length());
pstmt.setCharacterStream(2, isr_memo, fileMemo.length());
pstmt.setInt(3, dinfo_upload_id);

//System.out.println(sql_cn);

pstmt.execute();
stmt.executeUpdate("COMMIT");

}catch(Exception exce){
System.out.println(exce);
stmt.executeUpdate("ROLLBACK");
}
}
}
}catch(Exception e){
}

以上是jspsmart的方式,如果想要其它的方式,请下载全部源代码.

//upload_fileUpload.jsp

<%@ include file = "../../backgeneral.jsp"%>
<%@ contentType="text/html;charset=GBK" %>

<%@ page import="org.apache.commons.fileupload.*" %>
<%
try{
//request.setCharacterEncoding("GBK");
//取session 用户oid
 int pid = userInfo.getUserId();
 String sys_user_id = String.valueOf(pid);
//取init配置文件的参数值
String sitePhysicalPath = (String)init.getObject("SitePhysicalPath");
String saveDir = (String)init.getObject("InfoUploadDir");
String tempDir = (String)init.getObject("InfoUploadDir");
String fileMemo = ""; //文件说明
String fileName = null; //存储到数据库的文件名
String saveName = null; //存储到本地的文件名
String filePath = null; //存储到本地的文件路径
String savePath = null; //存储到数据库的文件路径
long fileSize = 0; //文件大小
int maxPostSize = -1;
int dinfo_upload_id = -1;
%>
<%
 DiskFileUpload df = new DiskFileUpload();
 //设定上传文件大小
df.setSizeMax(maxPostSize);
//设定临时目录
df.setRepositoryPath(sitePhysicalPath + tempDir);
 //取得request信息
List items = df.parseRequest(request);

Iterator iter = items.iterator();

int temp = 0;
FileItem tempItem = null;

while(iter.hasNext()){
  temp++;
  FileItem item = (FileItem)iter.next();
  if(item.isFormField())    //取得文件说明信息
  {
   fileMemo = item.getString("GBK");

  }
  else
  {   //取得上传文件信息
   fileName = (String)item.getName();
   try{
    fileName = fileName.substring(fileName.lastIndexOf("//")+1);
    fileName = fileName.substring(fileName.lastIndexOf("/")+1);
   }catch(Exception e){
    System.out.println(e);
   }
   fileSize = item.getSize();
   tempItem = item;
  }

if(temp == 2 && fileSize != 0)
{ //每两个iter存储一个上传文件

            //得到info_title_id
              String SQL_ID="select S_INFO_UPLOAD.nextval as seqid from dual";
           try {
                java.sql.Statement stmt = con.createStatement();
                java.sql.ResultSet rst= stmt.executeQuery(SQL_ID);
                while(rst.next())
       {
                       dinfo_upload_id = rst.getInt("seqid");
                }

             }catch(SQLException e1){
                    return;
             }
            //取得文件扩展名
            try{
    saveName = fileName.substring(fileName.lastIndexOf("."));
   }catch(Exception exc){
    saveName = "";
   }

            filePath = sitePhysicalPath + saveDir + Integer.toString(dinfo_upload_id) + saveName;
            //存储文件
   java.io.File uploadFile = new java.io.File(filePath);
   tempItem.write(uploadFile);
   /*try{
       FileOutputStream fos = new FileOutputStream(filePath);
       InputStream is = tempItem.getInputStream();
       byte[] b = new byte[1024];
       int nRead;
      long per = 0;
       double percent = 0;
                while((nRead = is.read(b, 0, 1024))>0){
        fos.write(b, 0, nRead);
        per += nRead;
        percent = (double)per/fileSize;

        session.setAttribute("percent",Double.toString(percent).substring(2,4));
        session.setAttribute("filename",fileName);
                }
       is.close();
    fos.close();
    }catch(Exception e){
     System.out.println(e);
    }*/
            savePath = saveDir + Integer.toString(dinfo_upload_id) + saveName;
            /*/存储数据库
            String sql = " INSERT INTO info_upload (info_upload_id,sys_user_id,file_name,file_memo,file_size,file_path,utime,deleted) "
              + " VALUES( " + Integer.toString(dinfo_upload_id) + "," + sys_user_id + ",'" + fileName + "','" + fileMemo + "'," + fileSize + ",'" + savePath + "', SYSDATE , 0 )" ;
   sqlcmd cmd = new sqlcmd(con,sql);
   */
            String sql = " INSERT INTO info_upload (info_upload_id,sys_user_id,file_size,file_path,utime,deleted) "
              + " VALUES( " + Integer.toString(dinfo_upload_id) + "," + sys_user_id + "," + fileSize + ",'" + savePath + "', SYSDATE , 0 )" ;
   sqlcmd cmd = new sqlcmd(con,sql);
            //System.out.println(sql);
   java.sql.PreparedStatement pstmt = null;
   java.sql.Statement stmt = null;
   //fileName = fileName.substring(0, fileName.indexOf("."));
   String sql_cn = " UPDATE info_upload SET file_name=?,file_memo=? WHERE info_upload_id=? ";

   java.io.ByteArrayInputStream bais_name = new java.io.ByteArrayInputStream(fileName.getBytes("ISO-8859-1"));
   java.io.InputStreamReader isr_name = new java.io.InputStreamReader((InputStream)bais_name,"GBK");

   java.io.ByteArrayInputStream bais_memo = new java.io.ByteArrayInputStream(fileMemo.getBytes("GBK"));
   java.io.InputStreamReader isr_memo = new java.io.InputStreamReader((InputStream)bais_memo,"GBK");

   try{
    stmt = con.createStatement();
    stmt.getConnection().setAutoCommit(false);

    pstmt = con.prepareStatement(sql_cn);
    pstmt.setCharacterStream(1, isr_name, fileName.length());
    pstmt.setCharacterStream(2, isr_memo, fileMemo.length());
    pstmt.setInt(3, dinfo_upload_id);

//System.out.println(sql_cn);

pstmt.execute();
stmt.executeUpdate("COMMIT");

   }catch(Exception exce){
    System.out.println(exce);
    stmt.executeUpdate("ROLLBACK");
   }

   temp = 0;
  }
  else if (temp == 2 && fileSize == 0) {temp = 0;}

}
//session.setAttribute("percent","ok");
}catch(Exception ex){
System.out.println(ex);
}
response.sendRedirect("list.jsp");

%>

//upload_jspSmart.jsp

<%@ include file = "../../backgeneral.jsp"%>
<%@ page language="java" import="java.util.*,java.sql.*,java.io.*"%>
<%@ page language="java" import="com.jspsmart.upload.*"%>
<%@ page language="java" import="com.ges.hbgov.*"%>

<%
//System.out.println("page=" + (String)session.getAttribute("SYS_USER_ID"));
if(!userInfo.Request(request)){
%>

<%
}
%>

try{
//取session 用户oid
 int pid = userInfo.getUserId();
 String sys_user_id = String.valueOf(pid);
//取init配置文件的参数值
String sitePhysicalPath = (String)init.getObject("SitePhysicalPath");
String saveDir = (String)init.getObject("InfoUploadDir");
String tempDir = (String)init.getObject("InfoUploadDir");
String fileMemo = ""; //文件说明
String fileName = null; //存储到数据库的文件名
String saveName = null; //存储到本地的文件名
String filePath = null; //存储到数据库的文件路径
String savePath = null; //存储到本地的文件路径
long fileSize = 0; //文件大小
int maxPostSize = -1;
int dinfo_upload_id = -1;
%>
<%
//初始化
mySmartUpload.initialize(pageContext);
//上载文件
 mySmartUpload.upload();
//循环取得所有上载文件
 for(int i=0; i {
 //取得上载文件
 com.jspsmart.upload.File file = mySmartUpload.getFiles().getFile(i);
 if(!file.isMissing())
 {
 fileName = file.getFileName();
 //取得文件扩展名file.getFileExt()
 try{
 saveName = fileName.substring(fileName.lastIndexOf("."));

   }catch(Exception e){
    saveName = "";
   }
   //取得文件大小
   fileSize = file.getSize();
   //存储路径
   String sql_id = " SELECT S_INFO_UPLOAD.nextval as seqid FROM dual ";
   try{
    Statement stmt = con.createStatement();
    ResultSet rst = stmt.executeQuery(sql_id);
    while(rst.next())
    {
     dinfo_upload_id = rst.getInt("seqid");
    }
   }catch(SQLException sqle){
    return;
   }

   filePath = sitePhysicalPath + saveDir + Integer.toString(dinfo_upload_id) + saveName;
   savePath = saveDir + Integer.toString(dinfo_upload_id) + saveName;
   //存储文件到本地
   file.saveAs(filePath);
   //存储文件到数据库
   switch(i)
   {
    case 0: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo1"); break;
    case 1: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo2"); break;
                case 2: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo3"); break;
    case 3: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo4"); break;
    case 4: fileMemo = (String)mySmartUpload.getRequest().getParameter("memo5"); break;
    default: fileMemo = "";
   }

            String sql = " INSERT INTO info_upload (info_upload_id,sys_user_id,file_size,file_path,utime,deleted) "
              + " VALUES( " + Integer.toString(dinfo_upload_id) + "," + sys_user_id + "," + fileSize + ",'" + savePath + "', SYSDATE , 0 )" ;
   sqlcmd cmd = new sqlcmd(con,sql);
            //System.out.println(sql);
   java.sql.PreparedStatement pstmt = null;
   java.sql.Statement stmt = null;
   //fileName = fileName.substring(0, fileName.indexOf("."));
   String sql_cn = " UPDATE info_upload SET file_name=?,file_memo=? WHERE info_upload_id=? ";
   java.io.ByteArrayInputStream bais_name = new java.io.ByteArrayInputStream(fileName.getBytes("ISO-8859-1"));
   java.io.InputStreamReader isr_name = new java.io.InputStreamReader((InputStream)bais_name,"GBK");

    pstmt = con.prepareStatement(sql_cn);
    pstmt.setCharacterStream(1, isr_name, fileName.length());
    pstmt.setCharacterStream(2, isr_memo, fileMemo.length());
    pstmt.setInt(3, dinfo_upload_id);

//System.out.println(sql_cn);

pstmt.execute();
stmt.executeUpdate("COMMIT");

   }catch(Exception exce){
    System.out.println(exce);
    stmt.executeUpdate("ROLLBACK");
   }
  }
}
}catch(Exception e){
}

response.sendRedirect("list.jsp");
%>

java处理xml方法

最初，XML 语言仅仅是意图用来作为 HTML 语言的替代品而出现的，但是随着该语言的不断发展和完善，人们越来越发现它所具有的优点：例如标记语言可扩展，严格的语法规定，可使用有意义的标记，内容存储和表现分离等等优势注定了该语言从诞生之日起就会走向辉煌。 XML 语言在成为 W3C 标准之后进入到了一个快速发展的时期，当然它本身所具有的一系列优点和优势也注定了各大技术厂商对它的偏爱，Java 作为软件行业的一种开发技术也迅速作出了反应，出现了多种对 XML 支持的工具，本文将会从这个角度对 Java 处理 XML 的几种主流技术进行介绍，希望能对您有所帮助。在这篇文章中，您将会得到以下信息：

Java 提供了哪些优秀的类库及工具便于程序员对 XML 进行处理 ?
有了 DOM 了，其它工具类库还有必要么 ?
几个小例程带你快速了解这三种解析方式

　　Java 有哪些优秀的类库及工具便于程序员对 XML 进行处理 ?

大名鼎鼎的 DOM
绿色环保的 SAX
默默无闻的 Digester

　　XML 三种解析方式简介

　　大名鼎鼎的 DOM

　　说它大名鼎鼎可是一点不为过，DOM 是 W3C 处理 XML 的标准 API，它是许多其它与 XML 处理相关的标准的基础，不仅是 Java，其它诸如 Javascript，PHP，MS .NET 等等语言都实现了该标准，成为了应用最为广泛的 XML 处理方式。当然，为了能提供更多更加强大的功能，Java 对于 DOM 直接扩展工具类有很多，比如很多 Java 程序员耳熟能详的 JDOM，DOM4J 等等，它们基本上属于对 DOM 接口功能的扩充，保留了很多 DOM API 的特性，许多原本的 DOM 程序员甚至都没有任何障碍就熟练掌握了另外两者的使用，直观、易于操作的方式使它深受广大 Java 程序员的喜爱。

　　绿色环保的 SAX

　　SAX 的应运而生有它特殊的需要，为什么说它绿色环保呢，这是因为 SAX 使用了最少的系统资源和最快速的解析方式对 XML 处理提供了支持。但随之而来繁琐的查找方式也给广大程序员带来许多困扰，常常令人头痛不已，同时它对 XPath 查询功能的支持，令人们对它又爱又恨。

　　默默无闻的 Digester：XML 的 JavaBean 化

　　Digester 是 apache 基金组织下的一个开源项目，笔者对它的了解源于对 Struts 框架的研究，是否有很多程序员想要一解各大开源框架的设计甚至想要自己写一个功能强大的框架时会碰到这样一个难题：这些形形色色的用 XML 语言标记的框架配置文件，框架底层是用什么技术来解析呢？ DOM 解析耗费时间，SAX 解析又过于繁琐，况且每次解析系统开销也会过大，于是，大家想到需要用与 XML 结构相对应的 JavaBean 来装载这些信息，由此 Digester 应运而生。它的出现为 XML 转换为 JavaBean 对象的需求带来了方便的操作接口，使得更多的类似需求得到了比较完美的解决方法，不再需要程序员自己实现此类繁琐的解析程序了。与此同时 SUN 也推出了 XML 和 JavaBean 转换工具类 JAXB，有兴趣的读者可以自行了解。

　　三种解析方式比较

　　DOM

　　优缺点：实现 W3C 标准，有多种编程语言支持这种解析方式，并且这种方法本身操作上简单快捷，十分易于初学者掌握。其处理方式是将 XML 整个作为类似树结构的方式读入内存中以便操作及解析，因此支持应用程序对 XML 数据的内容和结构进行修改，但是同时由于其需要在处理开始时将整个 XML 文件读入到内存中去进行分析，因此其在解析大数据量的 XML 文件时会遇到类似于内存泄露以及程序崩溃的风险，请对这点多加注意。

　　适用范围：小型 XML 文件解析、需要全解析或者大部分解析 XML、需要修改 XML 树内容以生成自己的对象模型

　　SAX

　　SAX 从根本上解决了 DOM 在解析 XML 文档时产生的占用大量资源的问题。其实现是通过类似于流解析的技术，通读整个 XML 文档树，通过事件处理器来响应程序员对于 XML 数据解析的需求。由于其不需要将整个 XML 文档读入内存当中，它对系统资源的节省是十分显而易见的，它在一些需要处理大型 XML 文档以及性能要求较高的场合有起了十分重要的作用。支持 XPath 查询的 SAX 使得开发人员更加灵活，处理起 XML 来更加的得心应手。但是同时，其仍然有一些不足之处也困扰广大的开发人员：首先是它十分复杂的 API 接口令人望而生畏，其次由于其是属于类似流解析的文件扫描方式，因此不支持应用程序对于 XML 树内容结构等的修改，可能会有不便之处。

　　适用范围：大型 XML 文件解析、只需要部分解析或者只想取得部分 XML 树内容、有 XPath 查询需求、有自己生成特定 XML 树对象模型的需求

　　Digester/JAXB

　　优缺点 : 由于其是在上述两者的基础上衍生出来的工具类，为的是满足将 XML 转换为 JavaBean 的特殊需求，故而没有什么特别明显的优缺点。作为大名鼎鼎的开源框架 Struts 的 XML 解析工具 Digester，为我们带来了将 XML 转换为 JavaBean 的可靠方法。

　　适用范围 : 有将 XML 文档直接转换为 JavaBean 需求。

　　应用示例

　　下面给出一段用于解析的 XML 片段：
　　清单 1. XML 片段

                 Harry Potter        J K. Rowling                  Learning XML        Erik T. Ray

　　DOM 解析 XML

　　Java 中的 DOM 接口简介： JDK 中的 DOM API 遵循 W3C DOM 规范，其中 org.w3c.dom 包提供了 Document、DocumentType、Node、NodeList、Element 等接口，这些接口均是访问 DOM 文档所必须的。我们可以利用这些接口创建、遍历、修改 DOM 文档。

　　javax.xml.parsers 包中的 DoumentBuilder 和 DocumentBuilderFactory 用于解析 XML 文档生成对应的 DOM Document 对象。

　　javax.xml.transform.dom 和 javax.xml.transform.stream 包中 DOMSource 类和 StreamSource 类，用于将更新后的 DOM 文档写入 XML 文件。

　　下面给出一个运用 DOM 解析 XML 的例子：
　　清单 2. DOM 解析 XML

 import java.io.File;   import java.io.IOException;   import javax.xml.parsers.DocumentBuilder;   import javax.xml.parsers.DocumentBuilderFactory;   import javax.xml.parsers.ParserConfigurationException;   import org.w3c.dom.Document;   import org.w3c.dom.Element;   import org.w3c.dom.Node;   import org.w3c.dom.NodeList;   import org.xml.sax.SAXException;   public class DOMParser {     DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();     //Load and parse XML file into DOM     public Document parse(String filePath) {        Document document = null;        try {           //DOM parser instance           DocumentBuilder builder = builderFactory.newDocumentBuilder();           //parse an XML file into a DOM tree           document = builder.parse(new File(filePath));        } catch (ParserConfigurationException e) {           e.printStackTrace();         } catch (SAXException e) {           e.printStackTrace();        } catch (IOException e) {           e.printStackTrace();        }        return document;     }     public static void main(String[] args) {           DOMParser parser = new DOMParser();           Document document = parser.parse("books.xml");           //get root element           Element rootElement = document.getDocumentElement();           //traverse child elements           NodeList nodes = rootElement.getChildNodes();           for (int i=0; i < nodes.getLength(); i++)           {              Node node = nodes.item(i);              if (node.getNodeType() == Node.ELEMENT_NODE) {                   Element child = (Element) node;                 //process child element              }           }           NodeList nodeList = rootElement.getElementsByTagName("book");           if(nodeList != null)           {              for (int i = 0 ; i < nodeList.getLength(); i++)              {                 Element element = (Element)nodeList.item(i);                 String id = element.getAttribute("id");              }           }     }   }

　　在上面的例子中，DOMParser 的 Parse() 方法负责解析 XML 文件并生成对应的 DOM Document 对象。其中 DocumentBuilderFactory 用于生成 DOM 文档解析器以便解析 XML 文档。在获取了 XML 文件对应的 Document 对象之后，我们可以调用一系列的 API 方便的对文档对象模型中的元素进行访问和处理。需要注意的是调用 Element 对象的 getChildNodes() 方法时将返回其下所有的子节点，其中包括空白节点，因此需要在处理子 Element 之前对节点类型加以判断。

　　可以看出 DOM 解析 XML 易于开发，只需要通过解析器建立起 XML 对应的 DOM 树型结构后便可以方便的使用 API 对节点进行访问和处理，支持节点的删除和修改等。但是 DOM 解析 XML 文件时会将整个 XML 文件的内容解析成树型结构存放在内存中，因此不适合用 DOM 解析很大的 XML 文件。

　　SAX 解析 XML

　　与 DOM 建立树形结构的方式不同，SAX 采用事件模型来解析 XML 文档，是解析 XML 文档的一种更快速、更轻量的方法。利用 SAX 可以对 XML 文档进行有选择的解析和访问，而不必像 DOM 那样加载整个文档，因此它对内存的要求较低。但 SAX 对 XML 文档的解析为一次性读取，不创建任何文档对象，很难同时访问文档中的多处数据。

　　下面是一个 SAX 解析 XML 的例子：
　　清单 3. SAX 解析 XML

 import org.xml.sax.Attributes;   import org.xml.sax.SAXException;   import org.xml.sax.XMLReader;   import org.xml.sax.helpers.DefaultHandler;   import org.xml.sax.helpers.XMLReaderFactory;   public class SAXParser {     class BookHandler extends DefaultHandler {        private List nameList;        private boolean title = false;        public List getNameList() {           return nameList;        }        // Called at start of an XML document        @Override        public void startDocument() throws SAXException {           System.out.println("Start parsing document...");           nameList = new ArrayList();        }        // Called at end of an XML document        @Override        public void endDocument() throws SAXException {            System.out.println("End");         }        /**         * Start processing of an element.         * @param namespaceURI  Namespace URI         * @param localName  The local name, without prefix         * @param qName  The qualified name, with prefix         * @param atts  The attributes of the element         */        @Override        public void startElement(String uri, String localName, String qName,           Attributes atts) throws SAXException {           // Using qualified name because we are not using xmlns prefixes here.           if (qName.equals("title")) {              title = true;           }        }        @Override        public void endElement(String namespaceURI, String localName, String qName)           throws SAXException {           // End of processing current element           if (title) {              title = false;           }        }        @Override        public void characters(char[] ch, int start, int length) {           // Processing character data inside an element           if (title) {              String bookTitle = new String(ch, start, length);              System.out.println("Book title: " + bookTitle);              nameList.add(bookTitle);           }        }     }     public static void main(String[] args) throws SAXException, IOException {        XMLReader parser = XMLReaderFactory.createXMLReader();        BookHandler bookHandler = (new SAXParser()).new BookHandler();        parser.setContentHandler(bookHandler);        parser.parse("books.xml");        System.out.println(bookHandler.getNameList());     }   }

　　SAX 解析器接口和事件处理器接口定义在 org.xml.sax 包中。主要的接口包括 ContentHandler、DTDHandler、EntityResolver 及 ErrorHandler。其中 ContentHandler 是主要的处理器接口，用于处理基本的文档解析事件；DTDHandler 和 EntityResolver 接口用于处理与 DTD 验证和实体解析相关的事件； ErrorHandler 是基本的错误处理接口。DefaultHandler 类实现了上述四个事件处理接口。上面的例子中 BookHandler 继承了 DefaultHandler 类，并覆盖了其中的五个回调方法 startDocument()、endDocument()、startElement()、endElement() 及 characters() 以加入自己的事件处理逻辑。

　　Digester 解析 XML

　　为了满足将 XML 转换为 JavaBean 的特殊需求，Apache 旗下的一个名为 Digester 的工具为我们提供了这么一个选择。由于最终是将 XML 转化为 JavaBean 存储在内存当中，故而解析性能等方面其实与使用者并没有多大关系。解析的关键在于用以匹配 XML 的模式以及规则等，由于该工具较为复杂，限于篇幅，作者只能给予简单的介绍。

　　下面是一个 Digester 解析 XML 的例子片段：
　　清单 4. Digester 解析 XML

 // 定义要解析的 XML 的路径，并初始化工具类  File input = new File("books.xml");   Digester digester = new Digester();   // 如果碰到了  这个标签，应该初始化 test.myBean.Books 这个 JavaBean 并填装相关内容  digester.addObjectCreate("books", "test.myBean.Books");   digester.addSetProperties("books");   // 如果碰到了  这个标签，同上初始化 test.myBean.Book 这个 JavaBean   digester.addObjectCreate("books/book", "test.myBean.Book");   digester.addSetProperties("books/book");   // 通过调用上面已经初始化过的 JavaBean 的 addBook() 方法来把多个  加到一个集合中  digester.addSetNext("books/book", "addBook", "test.myBean.Book");   // 定义好了上面的解析规则后，就可以开始进行解析工作了  Books books = (Books) digester.parse(input);

　　上述代码简单的向读者展示了 Digester 处理 XML 的一些要点，主要是说明了一些模式以及规则的匹配。简言之，Digester 就是一种用来把一个 XML 转化为一个与该 XML 结构类似的 JavaBean。你可以把 XML 根元素想象成一个 JavaBean，该根元素的 attribute 就是这个 JavaBean 的各种 Field，当该根元素有其他子 tag 时，又要把这个子 tag 想象成一个个新的 XML，将其视为一个新的 JavaBean，并作为一个 Field 加入到父 Bean 当中，然后以此类推，通过循环的方式将整个 XML 进行解析。

　　结束语

　　本文介绍了 Java 解析 XML 的三种常用技术，其中 DOM 易于上手，程序易于理解，但缺点在于占用内存大，不适合于解析较大的 XML 文件； SAX 基于事件模型占用系统资源少，能够胜任较大的 XML 文件解析，但解析过程较为繁琐查找元素不方便； Digester/JAXB 基于上述两种技术衍生而来。文中的实例向读者展示了三种 API 的基本使用方法，在实际开发过程中使用那种技术解析 XML 更好要依据各自的优缺点视具体情况而定。

前段开发10点

　第一日：初尝禁果

　　【上帝说：“要有光！”便有了光】

　　万物生灵、阳光雨露盖源于造物之初的天工开物，我们无法想象上帝创造光明之前的世界模样。但幸运的是，前端开发没有神祗般的诡魅。这个技术工种的孕育、定型、发展自有轨迹，也颇有渊源，当然，这非常容易理解。不严格的讲，在杨致远和费罗在斯坦福大学的机房里撺掇出Yahoo!时，Web前端技术就已经开始进入公众视野，只不过当时没有一个响亮的名字。从那时起，“基于浏览器端的开发”就成了软件开发的新的分支，这也是Web前端技术的核心，即不论何时何地何种系统以及怎样的设备，但凡基于浏览器，都是Web前端开发的范畴（当然，这个定义很狭隘，下文会提到）。

　　在2000年之后浏览器技术渐渐成熟，Web产品也越来越丰富，中国有大批年轻人开始接触互联网，有一点需要注意，大部分人接触互联网不是始于对浏览器功能的好奇，而是被浏览器窗口内的丰富内容所吸引，我们的思维模式从一开始就被限制在一个小窗口之内，以至于很长时间内我们将“视觉”认为是一种 “功能”，Web产品无非是用来展现信息之用。起初的入行者无一例外对“视觉”的关注超过了对“内容”的重视，先让页面看起来漂亮，去关注 html/css，沿着“视觉呈现”的思路，继续深入下去。因此，这类人是被“视觉”所吸引，从切页面入行，着迷于结构化的html和书写工整的css，喜欢简洁优雅的UI和工整的页面设计，之后开始接触视觉特效，并使用jQuery来实现视觉特效，以此为线索，开始深入研究Dom、Bom和浏览器的渲染机制等，html/css在这些人手中就像进攻兵器，而JavaScript则更如防守的盾牌。

　　还有另外一群人从另一条道路接触Web前端，即工程师转行做前端，他们有较多的后台语言开发背景，从读写数据开始，渐渐触及浏览器端，接触 JavaScript库，起初是在html代码上加js逻辑，后来开始涉及html和css，他们喜欢OO、逻辑清晰、结构悦目的代码，更关注界面背后的 “程序语言”和数据逻辑。html/css在这些人手中则更像盾牌，而JavaScript更如进攻的兵器。

　　应当说这两类人是互补的，他们各自了解浏览器本质的一部分，一拨人对渲染引擎了如指掌，另一拨人则将JS引擎奉为至宝，其实任何一部分的优势发挥出来都能做出精品。大部分前端工程师都能从这两条渊源中找到自己的影子。但，这两类人的思维模式和观点是如此不同，以至于形成了一些不必要的对抗，比如在某些公司，干脆将Web前端技术一分为二，“切页面的”和“写js的”。这样做看上去明确了分工提高了效率，但他对员工的职业发展带来巨大伤害。在第二日“科班秀才”中会有进一步讨论。

　　我应该属于第二类，即在学校正儿八经的学习C/Java和C#之类，以为大学毕业后能去做ERP软件、桌面软件或者进某些通信公司写TCP /IP相关的程序。校园招聘时选择了中国雅虎，因为当年（08年）雅虎还是有一点儿名气，而且我听说雅虎比较算技术流的公司……自此就上了贼船，一发不可收拾。

　　在雅虎的这段时间，我有幸接触到一股正气凛然的技术流派，也形成了我对前端技术的一些基本看法，这些基本观点一直影响我至今。

　　【优雅的学院派】

　　当年雅虎的技术流派正如日中天，拥有众多“之父”级的高人，所营造出的Hack氛围实在让人陶醉的无法自拔，那段时间我甚至宁愿加班到深夜阅读海量的文档和源代码，感觉真的很舒服，我深深的被雅虎工程师这种低调务实、精工细琢的“服务精神”所打动，而这种不起௬

你可能感兴趣的:(JAVA开发全集)

学生把我的课件换成小三认罪书(赵书晴宋诗月)全集阅读_学生把我的课件换成小三认罪书最新章节阅读_赵书晴宋诗月(学生把我的课件换成小三认罪书)全本免费在线阅读_(学生把我的课件换成小三认罪书)完结... 笔趣阁热门小说
学生把我的课件换成小三认罪书(赵书晴宋诗月)全集阅读_学生把我的课件换成小三认罪书最新章节阅读_赵书晴宋诗月(学生把我的课件换成小三认罪书)全本免费在线阅读_(学生把我的课件换成小三认罪书)完结版免费在线阅读_学生把我的课件换成小三认罪书(赵书晴宋诗月)完整版免费阅读_(学生把我的课件换成小三认罪书)全章节免费在线阅读主角配角：赵书晴宋诗月简介：我和赵京立去了民政局提交了申请因为离婚冷静期，还要再
最佳好女婿赵倩王城(精彩热门小说)最佳好女婿赵倩王城&全集目录免费阅读海边书楼
最佳好女婿赵倩王城(精彩热门小说)最佳好女婿赵倩王城&全集目录免费阅读主角：赵倩王城简介：女人叫赵倩，三十八岁，很漂亮，----阅读全文小说内容请翻阅文章最底部---王城根本没有想到，女友的妈妈在自乐的时候，叫的竟然是自己的名字。女人叫赵倩，三十八岁，很漂亮，腰很细，腿很长，王城有些怪异赵倩为什么会放过自己，但赵倩没有发怒，却也让王城长长的舒了一口气，坐到沙发上点了根烟抽了起来。“王城，什么时候回
Java 代理机制详解：从静态代理到动态代理，彻底掌握代理模式的原理与实战大葱白菜 java合集 java 开发语言后端个人开发学习代理模式
作为一名Java开发工程师，你一定在使用Spring、MyBatis、RPC框架等技术时接触过“代理”（Proxy）这个概念。无论是Spring的AOP（面向切面编程）、事务管理，还是远程调用、日志记录、权限控制等场景，代理机制都扮演着至关重要的角色。本文将带你全面掌握：什么是代理？静态代理与动态代理的区别JDK动态代理与CGLIB动态代理的实现原理代理模式的典型应用场景代理在主流框架中的使用（如
java web开发实战经典当当_java web项目实战开发飞翔的酋长大人 java web开发实战经典当当
本书以问题为导向，涵盖JavaWeb开发技术中所有的核心知识点；实战开发案例丰富，所有的知识案例都来源于企业真实项目，实战性和可操作性强；代码注释详细准确，结构简洁清晰；语言简明易懂，由浅入深地带你学会JavaWeb技术及应用。本书面向广大Java开发工程师和普通高校学生，可作为高等学校计算机及其相关专业Web编程技术课程教材，也可供从事JavaWeb应用开发的技术人员学习参考。¥80.00定价：
【实战】Java应用一键复制部署+基础数据自动迁移，这套方案绝了！混进IT圈 Java部署 Docker 数据迁移一键部署 MySQL升级 Flyway 镜像管理
前言：还在为部署和数据迁移头疼？作为Java开发者，你是否遇到过这些场景：辛辛苦苦搭好的应用环境，给同事复现一份要手把手教3小时？部署时要手动装JDK、数据库、配置环境变量，步骤繁琐还容易出错？基础数据（如管理员账号、字典表）每次都要手动导入，版本不同还会报错？今天就给大家分享一套一站式解决方案：从应用打包、环境复制到基础数据自动迁移，全程自动化，小白也能一键搞定！一、先搞定“系统打包复制”：环境
【Java基础面试题】Java特点，八种基本数据类型
Java的特点1.面向对象2.跨平台3.简单易学4.内存管理JVM、JDK、JRE的关系JVM：Java虚拟机，它负责把字节码文件进行编译并运行，是Java具有跨平台性的关键所在。它还有内存管理，垃圾回收等功能。JDK：JDK是Java开发工具包，它包含了JVM，编译器，调试器等开发工具，还包含一系列类库。它提供了Java程序编译，调试，运行所需要的工具和环境。JRE：是java运行时的最小环境，
网络安全第14集不灭锦鲤 web安全安全
前言：小迪安全14集，这集重点内容：0、什么是js渗透测试？在javascript中也存在变量和函数，存在可控变量和函数就有可能存在在漏洞，js开发的web应用和php、java开发的区别是，js能看得到的源代码，php看不到，但是风险就是未授权访问、配置信息泄露（加密算法、key秘钥等），源代码看得到，存在更多的url泄露，从而可能会出现未授权访问，从url，前提：web应用可以采用前端语言或后
张晓宋佳佳陈茹短文小说全集在线阅读_张晓宋佳佳陈茹过敏风波，以命赌命在线阅读《张晓宋佳佳陈茹》最新更新春天文库
张晓宋佳佳陈茹短文小说全集在线阅读_张晓宋佳佳陈茹过敏风波，以命赌命在线阅读《张晓宋佳佳陈茹》最新更新小说简介：室友张晓发了条关于我的帖子，标题是我室友好装呀，说自己过敏吃了芒果会死，甚至连芒果味都闻不了，现在是流行说自己过敏吗？评论区高赞全都是对我的声讨。张晓一一回复，“就是，我想吃就吃，谁也别想道德绑架我，我今晚就试试她是不是真的会死。”结果在我学习完回到寝室时，发现整个寝室弥漫着芒果味，我的
《死生时刻》泰剧【生死四分钟1080p超清泰语中字】免费在线观看4 Minutes(2024)全集完整未删减版夸克网盘高清迅雷网盘百度云全网优惠分享
泰剧《死生时刻》（又名《4分钟》或《生死四分钟》）是一部2024年的奇幻爱情剧情剧集，由杰迪帕·迪拉朋帕、温查帕·苏梅提固等主演。该剧讲述了商学院学生Great意外获得4分钟内预测未来的能力，以及他与外科住院医生Tyme之间的故事。资源链接：(尽快保存，随时失效)https://pan.quark.cn/s/8bf7ae9fd8c8备用：(资源完全免费,搜集于网络公开资源)https://driv
【技术精进】Java集合框架：从入门到精通的思考之路果冻kk java基础 Java集合 java python 开发语言
Java集合框架学习指南：一份完整的知识地图️前言JAVA集合，是每个Java开发者的必备武器。工作中的程序员都在使用它，因为它是数据处理中不可或缺的工具。说到如何优雅地使用、如何实现高性能、如何确保线程安全，相信大家都有自己的心得，毕竟实战中遇到的问题和解决方案都是最好的老师。但要说到底层实现原理、设计思想，可能就只有部分开发者有深入研究了。本文旨在帮助新手构建知识体系，也为老手提供系统复习的参
Spring框架深度解析
我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队
Spring框架核心技术解析
我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队
并发编程与MyBatis精髓 AIHacksCash Java场景面试宝典 Concurrency Java Database Framework
我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、Spri
ShardingSphere核心技术解析 AIHacksCash Java场景面试宝典 ShardingSphere Distributed Database Database Sharding
我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、Spri
ShardingSphere架构解析 AIHacksCash Java场景面试宝典 ShardingSphere Distributed Database Database Sharding
我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、Spri
[分享]钛极OS(TiJOS)物联网操作系统介绍
钛极OS(TiJOS)物联网操作系统介绍官方链接：http://dev.tijos.net/overview/TiJOS_overview/1.tijos_introduction/钛极OS(TiJOS)是一个支持使用Java开发嵌入式智能硬件应用的物联网操作系统，支持多种MCU芯片，为开发者提供高效、成熟的物联网应用开发平台，让智能硬件及IoT应用开发更快捷简单。钛极OS(TiJOS)可运行于低
娇养玫瑰：矜贵太子爷宠我上瘾(南淑儿祁景晔)全集阅读_娇养玫瑰：矜贵太子爷宠我上瘾最新章节阅读_娇养玫瑰：矜贵太子爷宠我上瘾(南淑儿祁景晔)全集阅读_娇养玫瑰：矜贵太子爷宠我上瘾最新章节阅读_南... 笔趣阁官方推荐小说
娇养玫瑰：矜贵太子爷宠我上瘾(南淑儿祁景晔)全集阅读_娇养玫瑰：矜贵太子爷宠我上瘾最新章节阅读_娇养玫瑰：矜贵太子爷宠我上瘾(南淑儿祁景晔)全集阅读_娇养玫瑰：矜贵太子爷宠我上瘾最新章节阅读_南淑儿祁景晔(娇养玫瑰：矜贵太子爷宠我上瘾)最新章节免费在线阅读_(南淑儿祁景晔)完结版在线阅读主角配角：南淑儿祁景晔简介：要不说顾少这人真性情呢，南倾倒贴这么多年，说不爱就不爱，不愧是顾少！要我说，南倾未免
孟思遐邵珈宸（孟思遐邵珈宸）全集完整版已完结大结局_孟思遐邵珈宸最新热点全文在线阅读（孟思遐邵珈宸）百鸣文库
简介：邵珈宸愣了愣，突然想起谈了三年，两个人好像确实没有拍过合照，正要开口，手机却响了起来。看见号码后，他抬手示意，先接了电话。小说书名：孤单是你给的苦主角：孟思遐，邵珈宸看完整版请滑到文章最下方！！！！！！———精彩内容试读———第六章再醒来时，看见坐在沙发上的邵珈宸时，孟思遐有些意外。见她醒了，他连忙放下书站起来。“之前不是说好要陪你去看日落吗，这几天天气并不好，我先陪你去环球影城吧，等天晴了
李子恒安雅(结婚纪念日，妻子带着白月光回家)全章节在线阅读_(结婚纪念日，妻子带着白月光回家)完结版免费阅读_李子恒安雅(结婚纪念日，妻子带着白月光回家)最新章节免费在线阅读_(李子恒安雅)完结... 笔趣阁官方推荐小说
李子恒安雅(结婚纪念日，妻子带着白月光回家)全章节在线阅读_(结婚纪念日，妻子带着白月光回家)完结版免费阅读_李子恒安雅(结婚纪念日，妻子带着白月光回家)最新章节免费在线阅读_(李子恒安雅)完结版在线阅读_结婚纪念日，妻子带着白月光回家(李子恒安雅)全集阅读_结婚纪念日，妻子带着白月光回家最新章节阅读主角配角：李子恒安雅简介：听到姜婉这个名字，安雅微微一愣，她下意识看向还未离开办公室的李子恒秘书盯
《报告太子：这个太子妃好眼熟》李延玺沈骊珠完结版阅读_李延玺沈骊珠完结版在线阅读_报告太子：这个太子妃好眼熟(李延玺沈骊珠)全集阅读_报告太子：这个太子妃好眼熟最新章节阅读_李延玺沈骊珠《报告太... 笔趣阁官方推荐小说
《报告太子：这个太子妃好眼熟》李延玺沈骊珠完结版阅读_李延玺沈骊珠完结版在线阅读_报告太子：这个太子妃好眼熟(李延玺沈骊珠)全集阅读_报告太子：这个太子妃好眼熟最新章节阅读_李延玺沈骊珠《报告太子：这个太子妃好眼熟》完整版在线阅读_李延玺沈骊珠完整版在线阅读主角配角：李延玺沈骊珠简介：在浅碧心下隐忧的时候，两匹骏马疾驰过金陵郡外官道，马蹄踏破落花，溅起的泥点洒在垂落下来的那一抹淡青色袍摆上抵达御仪
老公出轨，我被迫亲手让他绝后(雅君梁逸兴)免费小说全集_阅读免费小说老公出轨，我被迫亲手让他绝后雅君梁逸兴 957ace074429
《老公出轨，我被迫亲手让他绝后》主角：雅君梁逸兴简介：凌晨值夜班，救护车拉了个陷入昏迷的女孩儿来医院抢救。女孩儿大出血急需抢救。我拨通她手机里的紧急联系人：电话那头自称老公的男人，竟是我老公！我迫不得已，亲手给那女孩做了清宫术。听到熟悉的嗓音，我戴手套的动作一顿。第一反应是不是撞声了。「医生，我老婆她怎么不接电话？她到底怎么了？」我压着感冒初愈的嗓音耐心告诉他现在急需手术，让男人尽快赶来医院。「医
为你入狱，你却提离婚叶青高清月全集免费小说_完整版小说全文免费阅读为你入狱，你却提离婚(叶青高清月) 狂战书楼
《为你入狱，你却提离婚》主角：叶青高清月，简介：为了爱人，入狱三年，出狱后，却被律师送来一纸离婚协议。原因，竟然仅仅是因为我太平庸，已经配不上高高在上的你。那当你看到高不可攀的我之后，会忏悔，会哭吗？这一刻，林芝傻眼了，她不是没见过叶青，但是没见过这么混的叶青啊。这是在监狱里呆了三年，整个人都变了啊。疯了，疯了，真是疯了，打了人还不算，现在竟然还不让人走，不但如此，更是直接把高青树踩在了脚下，这也
遗憾随风起(慕司南苏小薇)最新章节在线阅读_(遗憾随风起)最新章节在线阅读_慕司南苏小薇(遗憾随风起)最新章节在线阅读_慕司南苏小薇全章节阅读_慕司南苏小薇(遗憾随风起)完整版免费在线阅读_《遗... 笔趣阁官方推荐小说
遗憾随风起(慕司南苏小薇)最新章节在线阅读_(遗憾随风起)最新章节在线阅读_慕司南苏小薇(遗憾随风起)最新章节在线阅读_慕司南苏小薇全章节阅读_慕司南苏小薇(遗憾随风起)完整版免费在线阅读_《遗憾随风起》全集在线阅读主角配角：慕司南苏小薇简介：相爱十年的男友终于向我求婚了我一时高兴，在订婚派对上多喝了两杯酒向来彬彬有礼的他却突然像是变了一个人一样呵斥我不懂规矩，把醉酒的我赶下车我忍着头疼，一个人在
许清如顾裴生《月亮若不来，就等晚风吹入怀》全本免费在线阅读_(许清如顾裴生)最新章节在线阅读_月亮若不来，就等晚风吹入怀(许清如顾裴生)完结版免费阅读_月亮若不来，就等晚风吹入怀全文免费阅读_许... 全本全集小说
许清如顾裴生《月亮若不来，就等晚风吹入怀》全本免费在线阅读_(许清如顾裴生)最新章节在线阅读_月亮若不来，就等晚风吹入怀(许清如顾裴生)完结版免费阅读_月亮若不来，就等晚风吹入怀全文免费阅读_许清如顾裴生《月亮若不来，就等晚风吹入怀》全文免费阅读_月亮若不来，就等晚风吹入怀全集在线阅读主角配角：许清如顾裴生简介：中秋节，老公陪小青梅回家吃饭凌晨小青梅更新了动态二十七岁的我们还和小时候一样睡在一起，
Java开发中对List＜Map＜String, Object＞＞集合去重并按大小拆分子列表
Java开发中对List>集合去重并按大小拆分子列表一、使用场景二、实现步骤三、相关知识四、代码示例一、使用场景在处理大量List>集合的数据时，为确保数据的唯一性，需要先根据Map的某个唯一标识进行去重，然后将去重后的数据切分成较小的子列表进行分组处理。二、实现步骤去重：通过将列表中的数据转换为Map，利用Map的键唯一性，去除重复的元素。同时，通过保留第一个出现的元素，可以确保数据的顺序。切分
杨倩时安《将她的爱埋至深底》全文免费阅读_将她的爱埋至深底全集在线阅读_杨倩时安(将她的爱埋至深底)最新章节在线阅读_杨倩时安全章节阅读_《将她的爱埋至深底》杨倩时安完结版阅读_杨倩时安完结版在线阅读完整版全集小说
杨倩时安《将她的爱埋至深底》全文免费阅读_将她的爱埋至深底全集在线阅读_杨倩时安(将她的爱埋至深底)最新章节在线阅读_杨倩时安全章节阅读_《将她的爱埋至深底》杨倩时安完结版阅读_杨倩时安完结版在线阅读主角配角：杨倩时安简介：5话音落下，在场的三人都怔住了还是我妈先一步反应过来，恨铁不成钢道：“你这说的什么混账话，赶紧道歉啊！”我冷眼看着她，心里渐渐恢复了平静淡声道：“如果你还把我当你儿子，就不要再
微博热文程实夏宁虞白薇全集免费试读-追你时装高冷，我选呆萌校花你哭啥全文多人追更春天文库
热文程实夏宁虞白薇全集免费试读-追你时装高冷，我选呆萌校花你哭啥全文多人追更小说简介：【怕不是个哑巴——】程实干脆直接坐下。有人的话，就抬**走人呗，多大个事。做题的过程很枯燥，程实偶尔会抬头看看对面高冷少女——确实养眼呀。古人都知道、用“书中自有颜如玉”来建立正反馈。程实今天都不需要在书里面找——颜如玉就坐他对面。书名：《追你时装高冷，我选呆萌校花你哭啥》主角配角：程实夏宁虞白薇【怕不是个哑巴—
上山探险，我打脸苗疆圣女(沈映雪映雪)全集阅读_上山探险，我打脸苗疆圣女最新章节阅读_沈映雪映雪《上山探险，我打脸苗疆圣女》完结版免费阅读_上山探险，我打脸苗疆圣女全文免费阅读_沈映雪映雪《上山... 笔趣阁官方账号
上山探险，我打脸苗疆圣女(沈映雪映雪)全集阅读_上山探险，我打脸苗疆圣女最新章节阅读_沈映雪映雪《上山探险，我打脸苗疆圣女》完结版免费阅读_上山探险，我打脸苗疆圣女全文免费阅读_沈映雪映雪《上山探险，我打脸苗疆圣女》最新章节阅读_(上山探险，我打脸苗疆圣女)全章节免费在线阅读主角配角：沈映雪映雪简介：但说笑声淹没了我的警告有那么一两个听到的同学也只是不屑的看了我一眼地面开始震动，泥土翻飞，无数黑点
《今夜一起为爱鼓掌》台剧/电视剧全集资源【1080p超清】免费在线观看完整未删减版在哪看百度云/夸克迅雷UC网盘资源优惠攻略官
台剧《今夜一起为爱鼓掌》是一部以性治疗为题材的电视剧，由李俊宏导演，杨谨华、杨祐宁、陈嘉桦、王柏杰等演员主演。该剧讲述了两位性格迥异的女性，张佳晨（杨谨华饰）和宋青语（陈嘉桦饰），在探索性与爱的平衡中找到救赎的故事。张佳晨是一位性治疗师，虽然在性爱技巧上非常熟练，但在个人感情生活中却遇到了挑战。而宋青语则面临着与丈夫之间的性障碍问题。两人在治疗过程中，不仅帮助他人解决性与爱的困扰，也在相互扶持中找
《非常律师禹英禑》韩剧全16集百度网盘资源哪里看免费全集大结局资源1080p下载剧情更新平台夸克迅雷阿里网盘 6a3de85245co
备受关注的韩剧《非常律师禹英禑》终于迎来全16集的大结局。在这部剧中，主人公禹英禑（金南珠饰）凭借过人的法律才能和坚定的信念，一次次为弱势群体伸张正义，成为了无数观众心中的正义女神。而这部作品的1080p画质也完美呈现了剧中每一个细腻的情感和紧张的氛围。提示：文章排版原因，观影资源链接地址放在文章结尾，往下翻就行提示：文章排版原因，观影资源链接地址放在文章结尾，往下翻就行在最后一集中，禹英禑面对的
算法单链的创建与删除换个号韩国红果果 c 算法
先创建结构体 struct student { int data; //int tag;//标记这是第几个 struct student *next; }; // addone 用于将一个数插入已从小到大排好序的链中 struct student *addone(struct student *h,int x){ if(h==NULL) //??????
《大型网站系统与Java中间件实践》第2章读后感白糖_ java中间件
断断续续花了两天时间试读了《大型网站系统与Java中间件实践》的第2章，这章总述了从一个小型单机构建的网站发展到大型网站的演化过程---整个过程会遇到很多困难，但每一个屏障都会有解决方案，最终就是依靠这些个解决方案汇聚到一起组成了一个健壮稳定高效的大型系统。看完整章内容，
zeus持久层spring事务单元测试 deng520159 java DAO spring jdbc
今天把zeus事务单元测试放出来,让大家指出他的毛病, 1.ZeusTransactionTest.java 单元测试 package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Test; import
Rss 订阅开发周凡杨 html xml 订阅 rss 规范
RSS是 Really Simple Syndication的缩写（对rss2.0而言，是这三个词的缩写，对rss1.0而言则是RDF Site Summary的缩写，1.0与2.0走的是两个体系）。 RSS
分页查询实现 g21121 分页查询
在查询列表时我们常常会用到分页，分页的好处就是减少数据交换，每次查询一定数量减少数据库压力等等。按实现形式分前台分页和服务器分页：前台分页就是一次查询出所有记录，在页面中用js进行虚拟分页，这种形式在数据量较小时优势比较明显，一次加载就不必再访问服务器了，但当数据量较大时会对页面造成压力，传输速度也会大幅下降。服务器分页就是每次请求相同数量记录，按一定规则排序，每次取一定序号直接的数据
spring jms异步消息处理 510888780 jms
spring JMS对于异步消息处理基本上只需配置下就能进行高效的处理。其核心就是消息侦听器容器，常用的类就是DefaultMessageListenerContainer。该容器可配置侦听器的并发数量，以及配合MessageListenerAdapter使用消息驱动POJO进行消息处理。且消息驱动POJO是放入TaskExecutor中进行处理，进一步提高性能，减少侦听器的阻塞。具体配置如下：
highCharts柱状图布衣凌宇 hightCharts 柱图
第一步：导入 exporting.js,grid.js,highcharts.js;第二步：写controller @Controller@RequestMapping(value="${adminPath}/statistick")public class StatistickController { private UserServi
我的spring学习笔记2-IoC（反向控制依赖注入） aijuans spring mvc Spring 教程 spring3 教程 Spring 入门
IoC（反向控制依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明：如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
TLS java简单实现 antlove java ssl keystore tls secure
1. SSLServer.java package ssl; import java.io.FileInputStream; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.security.KeyStore; import
Zip解压压缩文件百合不是茶 Zip格式解压 Zip流的使用文件解压
ZIP文件的解压缩实质上就是从输入流中读取数据。Java.util.zip包提供了类ZipInputStream来读取ZIP文件,下面的代码段创建了一个输入流来读取ZIP格式的文件; ZipInputStream in = new ZipInputStream(new FileInputStream(zipFileName)); &n
underscore.js 学习（一） bijian1013 JavaScript underscore
工作中需要用到underscore.js，发现这是一个包括了很多基本功能函数的js库，里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。学
java jvm常用命令工具——jstatd命令(Java Statistics Monitoring Daemon) bijian1013 java jvm jstatd
1.介绍 jstatd是一个基于RMI（Remove Method Invocation）的服务程序，它用于监控基于HotSpot的JVM中资源的创建及销毁，并且提供了一个远程接口允许远程的监控工具连接到本地的JVM执行命令。 jstatd是基于RMI的，所以在运行jstatd的服务
【Spring框架三】Spring常用注解之Transactional bit1129 transactional
Spring可以通过注解@Transactional来为业务逻辑层的方法(调用DAO完成持久化动作)添加事务能力，如下是@Transactional注解的定义： /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version
我(程序员)的前进方向 bitray 程序员
作为一个普通的程序员,我一直游走在java语言中,java也确实让我有了很多的体会.不过随着学习的深入,java语言的新技术产生的越来越多,从最初期的javase,我逐渐开始转变到ssh,ssi,这种主流的码农,.过了几天为了解决新问题,webservice的大旗也被我祭出来了,又过了些日子jms架构的activemq也开始必须学习了.再后来开始了一系列技术学习,osgi,restful.....
nginx lua开发经验总结 ronin47
使用nginx lua已经两三个月了，项目接开发完毕了，这几天准备上线并且跟高德地图对接。回顾下来lua在项目中占得必中还是比较大的，跟PHP的占比差不多持平了，因此在开发中遇到一些问题备忘一下 1：content_by_lua中代码容量有限制，一般不要写太多代码，正常编写代码一般在100行左右（具体容量没有细心测哈哈，在4kb左右），如果超出了则重启nginx的时候会报 too long pa
java-66-用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。颠倒之后的栈为{5,4,3,2,1}，5处在栈顶 bylijinnan java
import java.util.Stack; public class ReverseStackRecursive { /** * Q 66.颠倒栈。 * 题目：用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。 * 颠倒之后的栈为{5,4,3,2,1}，5处在栈顶。 *1. Pop the top element *2. Revers
正确理解Linux内存占用过高的问题 cfyme linux
Linux开机后，使用top命令查看，4G物理内存发现已使用的多大3.2G，占用率高达80%以上： Mem: 3889836k total, 3341868k used, 547968k free, 286044k buffers Swap: 6127608k total,&nb
[JWFD开源工作流]当前流程引擎设计的一个急需解决的问题 comsci 工作流
当我们的流程引擎进入IRC阶段的时候，当循环反馈模型出现之后，每次循环都会导致一大堆节点内存数据残留在系统内存中，循环的次数越多，这些残留数据将导致系统内存溢出，并使得引擎崩溃。。。。。。而解决办法就是利用汇编语言或者其它系统编程语言，在引擎运行时，把这些残留数据清除掉。
自定义类的equals函数 dai_lm equals
仅作笔记使用 public class VectorQueue { private final Vector<VectorItem> queue; private class VectorItem { private final Object item; private final int quantity; public VectorI
Linux下安装R语言 datageek R语言 linux
命令如下：sudo gedit /etc/apt/sources.list1、deb http://mirrors.ustc.edu.cn/CRAN/bin/linux/ubuntu/ precise/ 2、deb http://dk.archive.ubuntu.com/ubuntu hardy universesudo apt-key adv --keyserver ke
如何修改mysql 并发数(连接数)最大值 dcj3sjt126com mysql
MySQL的连接数最大值跟MySQL没关系，主要看系统和业务逻辑了方法一：进入MYSQL安装目录打开MYSQL配置文件 my.ini 或 my.cnf查找 max_connections=100 修改为 max_connections=1000 服务里重起MYSQL即可　　方法二：MySQL的最大连接数默认是100客户端登录：mysql -uusername -ppass
单一功能原则 dcj3sjt126com 面向对象的程序设计软件设计编程原则
单一功能原则[ 编辑] SOLID 原则单一功能原则开闭原则 Liskov代换原则接口隔离原则依赖反转原则查论编在面向对象编程领域中，单一功能原则（Single responsibility principle）规定每个类都应该有
POJO、VO和JavaBean区别和联系 fanmingxing VO POJO javabean
POJO和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Plain Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比POJO复杂很多，JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被
SpringSecurity3.X--LDAP：AD配置 hanqunfeng SpringSecurity
前面介绍过基于本地数据库验证的方式，参考http://hanqunfeng.iteye.com/blog/1155226，这里说一下如何修改为使用AD进行身份验证【只对用户名和密码进行验证，权限依旧存储在本地数据库中】。将配置文件中的如下部分删除：
mac mysql 修改密码 IXHONG mysql
$ sudo /usr/local/mysql/bin/mysqld_safe –user=root & //启动MySQL(也可以通过偏好设置面板来启动)$ sudo /usr/local/mysql/bin/mysqladmin -uroot password yourpassword //设置MySQL密码（注意，这是第一次MySQL密码为空的时候的设置命令，如果是修改密码，还需在-
设计模式--抽象工厂模式 kerryg 设计模式
抽象工厂模式：工厂模式有一个问题就是，类的创建依赖于工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。我们采用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。总结：这个模式的好处就是，如果想增加一个功能，就需要做一个实现类，
评"高中女生军训期跳楼” nannan408
首先，先抛出我的观点，各位看官少点砖头。那就是，中国的差异化教育必须做起来。孔圣人有云：有教无类。不同类型的人，都应该有对应的教育方法。目前中国的一体化教育，不知道已经扼杀了多少创造性人才。我们出不了爱迪生，出不了爱因斯坦，很大原因，是我们的培养思路错了，我们是第一要“顺从”。如果不顺从，我们的学校，就会用各种方法，罚站，罚写作业，各种罚。军
scala如何读取和写入文件内容？ qindongliang1922 java jvm scala
直接看如下代码： package file import java.io.RandomAccessFile import java.nio.charset.Charset import scala.io.Source import scala.reflect.io.{File, Path} /** * Created by qindongliang on 2015/
C语言算法之百元买百鸡 qiufeihu c 算法
中国古代数学家张丘建在他的《算经》中提出了一个著名的“百钱买百鸡问题”，鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁，母，雏各几何？代码如下： #include <stdio.h> int main() { int cock,hen,chick; /*定义变量为基本整型*/ for(coc
Hadoop集群安全性：Hadoop中Namenode单点故障的解决方案及详细介绍AvatarNode wyz2009107220 NameNode
正如大家所知，NameNode在Hadoop系统中存在单点故障问题，这个对于标榜高可用性的Hadoop来说一直是个软肋。本文讨论一下为了解决这个问题而存在的几个solution。 1. Secondary NameNode 原理：Secondary NN会定期的从NN中读取editlog，与自己存储的Image进行合并形成新的metadata image 优点：Hadoop较早的版本都自带，

按字母分类： A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 其他

JAVA开发全集

soap消息的分析和消息的创建和传递和处理

schema的笔记

dtd讲解

使用soap协议用java语言建立服务发送xml文件，接收xml文件

XPath解析，写入，修改xml文件

XMLEventReader的基于Filter的过滤方式解析xml文件

XMLEventReader迭代解析xml文件

XMLStreamReader光标解析xml文件

使用jaxb完成对象和xml的转换

webservice的笔记

js笔记

javascript技巧

jquery得到radio单选框的值

jpa 多对多查询hql语句

java--dom读取xml文件

jquery添加节点和删除节点例子

jquery创建节点元素

javascript取得表单对象的几种方法

javascript鼠标和键盘事件和关闭浏览器时的提示语

javascript得到事件和元素的跨浏览器方法

javascript事件对象event

javascript跨浏览器事件

javascript冒泡事件和捕获事件

javascript操作css

数据库并发

javascript数组方法

java排序

java io

java I/O库的设计原则

java I/O库的两个对称性

java I/O库的两个设计模式

装饰模式的应用

InputStream类型中的装饰模式

原始流处理器

链接流处理器

抽象结构图

装饰模式的各个角色

OutputStream 类型中的装饰模式

OutputStream类型有哪些子类

原始流处理器

链接流处理器

装饰模式的各个角色

Reader类型中的装饰模式

Writer类型中的装饰模式

适配器模式的应用

InputStream原始流处理器中的适配器模式

ByteArrayInputStream是一个适配器类

StringBufferInputStream是一个适配器类

OutputStream原始流处理器中的适配器模式

从byte流到char流的适配

InputStreamReader

poi读取excel

java io 设计模式

jquery对象和javascript的dom对象转换

javascript创建新节点方法

javascript面向对象中继承的几种方式

javascript模拟java中的StringBuffer连接字符串

javascript面向对象创建对象的五种方法

ajax下拉框联动

ajax笔记1

javascrip对象方法和数组方法

javascript闭包

jdbc的增删改查的方法

计算两个时间段相隔多少天的java方法

java反射常用方法

设计模式之门面模式

推荐免费下载430套大型商业源码

Struts2之annotation注解验证

$.cookie的用法

jdbc

设计模式之备忘录模式

设计模式之中介者模式

extjs 中判断坐标是否在选择区域中

extjs中触发隐藏和出现的方法

extjs得到图片的坐标和让图片某一区域可以点击

访问tomcat时只输入ip就可以访问系统的方法

extjs下拉框点击一行触发事件，得到valueField和displayField的值

Hibernate Fetch策略

hibernate抓取策略（单端代理的批量抓取）