java各种开发框架总结

关键词：框架

java各种开发框架总结（共5篇）

篇1：java各种开发框架总结

一、利用jdk web服务api实现，这里使用基于 SOAP message 的 Web 服务

1.首先建立一个Web services EndPoint：

Java代码

package Hello;

import javax.jws.WebService;

import javax.jws.WebMethod;

import javax.xml.ws.Endpoint;

@WebService

public class Hello {

@WebMethod

public String hello(String name){

return “Hello, ” + name + “n”;}

public static void main(String[] args){

// create and publish an endpoint

Hello hello = new Hello();

Endpoint endpoint Endpoint.publish(“http://localhost:8080/hello”, hello);

} }

2.使用 apt 编译 Hello.java(例：apt-d [存放编译后的文件目录] Hello.java),会生成 jaws目录

3.使用java Hello.Hello运行，然后将浏览器指向http://localhost:8080/hello?wsdl就会出现下列显示

4.使用wsimport 生成客户端

使用如下：wsimport-p.-keep http://localhost:8080/hello?wsdl

5.客户端程序：

Java代码

1.class HelloClient{ 2.3.public static void main(String args[]){ 4.5.HelloService service = new HelloService();6.7.Hello helloProxy = service.getHelloPort();8.9.String hello = helloProxy.hello(“你好”);10.11.System.out.println(hello);12.13.} 14.15.} 16.二、使用xfire，我这里使用的是myeclipse集成的xfire进行测试的

利用xfire开发WebService，可以有三种方法：

1一种是从javabean 中生成；

一种是从wsdl文件中生成；

还有一种是自己建立webservice

步骤如下：

用myeclipse建立webservice工程，目录结构如下：

首先建立webservice接口，代码如下：

Java代码

1.package com.myeclipse.wsExample;2.3.//Generated by MyEclipse 4.5.6.7.public interface IHelloWorldService { 8.9.10.11.public String example(String message);12.13.14.15.} 16.Java代码

1.package com.myeclipse.wsExample;2.3.//Generated by MyEclipse 4.5.6.7.public class HelloWorldServiceImpl implements IHelloWorldService { 8.9.10.11.public String example(String message){ 12.13.return message;14.15.} 16.17.18.19.} 20.修改service.xml 文件，加入以下代码：

Xml代码

1.2.3. 4.5.HelloWorldService 6.7. 8.9.com.myeclipse.wsExample.IHelloWorldService 10.11. 12.13. 14.15.com.myeclipse.wsExample.HelloWorldServiceImpl 16.17. 18.19. 20.21.literal 22.23.application 24.25. 26.把整个项目部署到tomcat服务器中，打开浏览器，输入http://localhost:8989/HelloWorld/services/HelloWorldService?wsdl

客户端实现如下：

Java代码

1.package com.myeclipse.wsExample.client;2.3.import java.net.MalformedURLException;4.5.import java.net.URL;6.7.8.9.import org.codehaus.xfire.XFireFactory;10.11.import org.codehaus.xfire.client.Client;12.13.import org.codehaus.xfire.client.XFireProxyFactory;14.15.import org.codehaus.xfire.service.Service;16.17.import org.codehaus.xfire.service.binding.ObjectServiceFactory;18.19.20.21.import com.myeclipse.wsExample.IHelloWorldService;22.23.24.25.public class HelloWorldClient { 26.27.public static void main(String[] args)throws MalformedURLException, Exception { 28.29.// TODO Auto-generated method stub 30.31.Service s=new ObjectServiceFactory().create(IHelloWorldService.class);32.33.XFireProxyFactory xf=new XFireProxyFactory(XFireFactory.newInstance().getXFire());34.35.String url=“http://localhost:8989/HelloWorld/services/HelloWorldService”;36.37.38.39.try 40.41.{ 42.43.44.45.IHelloWorldService hs=(IHelloWorldService)xf.create(s,url);46.47.String st=hs.example(“zhangjin”);48.49.System.out.print(st);50.51.} 52.53.catch(Exception e)54.55.{ 56.57.e.printStackTrace();58.59.} 60.61.} 62.63.64.65.} 66.这里再说点题外话，有时候我们知道一个wsdl地址，比如想用java客户端引用.net 做得webservice，使用myeclipse引用，但是却出现无法通过验证的错误，这时我们可以直接在类中引用，步骤如下：

Java代码

1.public static void main(String[] args)throws MalformedURLException, Exception { 2.3.// TODO Auto-generated method stub 4.5.Service s=new ObjectServiceFactory().create(IHelloWorldService.class);6.7.XFireProxyFactory xf=new XFireProxyFactory(XFireFactory.newInstance().getXFire());8.9.10.11.//远程调用.net开发的webservice 12.13.Client c=new Client(new URL(“http:///axis2/

同理，也需要将axis2复制到webapp目录中

在axis2中部署webservice有两种方法，第一种是pojo方式，这种方式比较简单，但是有一些限制，例如部署的类不能加上包名

第二种方式是利用xml发布webservice，这种方法比较灵活，不需要限制类的声明

下面分别说明使用方法：

1.pojo方式：在Axis2中不需要进行任何的配置，就可以直接将一个简单的POJO发布成WebService。其中POJO中所有的public方法将被发布成WebService方法。先实现一个pojo类：

Java代码

1.public class HelloWorld{ 2.3.public String getName(String name)4.5.{ 6.7.return ”你好 “ + name;8.9.} 10.11.public int add(int a,int b)12.13.{ 14.15.return a+b;16.17.} 18.19.} 20.由于这两个方法都是public类型，所以都会发布成webservice。编译HelloWorld类后，将HelloWorld.class文件放到%tomcat%webappsaxis2WEB-INFpojo目录中（如果没有pojo目录，则建立该目录），然后打开浏览器进行测试：

输入一下url：

http://localhost:8080/axis2/services/listServices

会列出所有webservice

这是其中的两个webservice列表，接着，在客户端进行测试：

首先可以写一个封装类，减少编码，代码如下：

Java代码

1.package MZ.GetWebService;2.3.import javax.xml.namespace.QName;4.5.6.7.import org.apache.axis2.AxisFault;8.9.import org.apache.axis2.addressing.EndpointReference;10.11.import org.apache.axis2.client.Options;12.13.import org.apache.axis2.rpc.client.RPCServiceClient;14.15.16.17.18.19.public class GetWSByAxis2 { 20.21.private static String EndPointUrl;22.23.private static String QUrl=”http://ws.apache.org/axis2“;

24.25.private QName opAddEntry;26.27.public String WSUrl;28.29.public RPCServiceClient setOption()throws AxisFault 30.31.{ 32.33.RPCServiceClient serviceClient = new RPCServiceClient();34.35.Options options = serviceClient.getOptions();36.37.EndpointReference targetEPR = new EndpointReference(WSUrl);38.39.options.setTo(targetEPR);40.41.return serviceClient;42.43.} 44.45.46.47.public QName getQname(String Option){ 48.49.50.51.return new QName(QUrl,Option);52.53.} 54.55.//返回String 56.57.public String getStr(String Option)throws AxisFault 58.59.{ 60.61.RPCServiceClient serviceClient =this.setOption();62.63.64.65.opAddEntry =this.getQname(Option);66.67.68.69.String str =(String)serviceClient.invokeBlocking(opAddEntry, 70.71.new Object[]{}, new Class[]{String.class })[0];72.73.return str;74.75.} 76.77.// 返回一维String数组 78.79.public String[] getArray(String Option)throws AxisFault

80.81.{ 82.83.RPCServiceClient serviceClient =this.setOption();84.85.86.87.opAddEntry =this.getQname(Option);88.89.90.91.String[] strArray =(String[])serviceClient.invokeBlocking(opAddEntry, 92.93.new Object[]{}, new Class[]{String[].class })[0];94.95.return strArray;96.97.} 98.99.//从WebService中返回一个对象的实例

100.101.public Object getObject(String Option,Object o)throws AxisFault 102.103.{ 104.105.RPCServiceClient serviceClient =this.setOption();106.107.QName qname=this.getQname(Option);108.109.Object object = serviceClient.invokeBlocking(qname, new Object[]{},new Class[]{o.getClass()})[0];110.111.return object;112.113.} 114.115.116.117.///////////////////////////////////////// 读者可以自己封装数据类型，如int,byte,float等数据类型

118.119.} 120.客户端调用方法：

Java代码

1.MZ.GetWebService.GetWSByAxis2 ws=new MZ.GetWebService.GetWSByAxis2();2.3.ws.WSUrl=”http://localhost:8989/axis2/services/HelloWorld“;4.5.HelloWorld hello=(HelloWorld)ws.getObject(”getName“, HelloWorld.class);6.7.8.9.10.11.System.out.println(hello.getName(”zhangjin“));12.2.使用service.xml发布webservice，这种方式和直接放在pojo目录中的POJO类不同。要想将MyService类发布成Web Service，需要一个services.xml文件，这个文件需要放在META-INF目录中，该文件的内容如下：

Xml代码

1. 2.3. 4.5.HelloWorld webservice 6.7. 8.9.10.11.service.HelloWorld 12.13. 14.15. 16.17. 20.21. 24.25. 26.27. 28.其中元素用于发布Web Service，一个元素只能发布一个WebService类，name属性表示WebService名，如下面的URL可以获得这个WebService的WSDL内容：

http://localhost:8080/axis2/services/myService?wsdl

除此之外，还有直接可以在其中制定webservice操作方法：可以这样些service.xml文件

Java代码

1. 2.3. 4.5.HelloWorld service 6.7. 8.9.

10.11.service.HelloWorld 12.13. 14.15. 16.17. 18.19. 20.21. 22.23. 26.27. 28.29. 30.如果要发布多个webservice，可以在文件两段加上...发布

篇2：java各种开发框架总结

Collection是集合框架层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。Collection接口下有最常用的接口为List跟Set。需要注意的是，Map并没有实现Collection接口。

List接口实现类ArrayList 优点：类似数组的形式进行存储，因此它的随机访问速度极快。缺点：不适合于在线性表中间需要频繁进行插入和删除操作。因为每次插入和删除都需要移动数组中的元素，它是用数组存储元素的，这个数组可以动态创建，如果元素个数超过了数组的容量，那么就创建一个更大的新数组，并将当前数组中的所有元素都复制到新数组中。[html] view plain copy public class ArrayListTest {

public static void main(String[] args){

List arrayList=new ArrayList();

arrayList.add(“Welcome”);

arrayList.add(“to”);

arrayList.add(“java”);

//把ArrayList变为数组相关的内容进行遍历

String[] strArray=new String[arrayList.size()];

arrayList.toArray(strArray);

for(int i=0;i

//使用迭代器进行ArrayList遍历

Iterator iter=arrayList.iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

List接口实现类LinkedList 优点：适合于在链表中间需要频繁进行插入和删除操作。

缺点：随机访问速度较慢。查找一个元素需要从头开始一个一个的找。此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作LinkedList是在一个链表中存储元素。[html] view plain copy public class LinkedListTest {

public static void main(String[] args){

List linkedList=new LinkedList();

//使用ForEach遍历linkedList

String[] strArray2=new String[linkedList.size()];

linkedList.toArray(strArray2);

for(int i=0;i

//foreach遍历LinkedList

for(String str:linkedList){

System.out.println(str);

}

//使用迭代器进行ArrayList遍历

Iterator iter=linkedList.iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

List接口实现类Vector：

Vector使用了关键字synchronized将访问和修改向量的方法都变成同步的了，所以对于不需要同步的应用程序来说，类ArrayList比类Vector更高效。相同点：

①都继承于AbstractList，并且实现List接口

②都实现了RandomAccess和Cloneable接口

③都是通过数组实现的，本质上都是动态数组，默认数组容量是10 ④都支持Iterator和listIterator遍历

不同点： ①ArrayList是非线程安全，而Vector是线程安全的

②容量增加方式不同，Vector默认增长为原来一倍，而ArrayList却是原来的一半+1 ③Vector支持通过Enumeration去遍历，而List不支持

[html] view plain copy public class VectorTest {

public static void main(String[] args){

Vector vector = new Vector();

for(int i = 0;i < 10;i++){

vector.add(i);

}

//直接打印

System.out.println(vector.toString());

//size()

System.out.println(vector.size());

//contains

System.out.println(vector.contains(2));

//总结：对比Vector的遍历方式，使用索引的随机访问方式最快，使用迭代器最慢

//iterator遍历

Iterator iterator = vector.iterator();

while(iterator.hasNext()){

System.out.print(iterator.next()+ “ ”);

}

//Enumeration遍历

Enumeration enu = vector.elements();

while(enu.hasMoreElements()){

System.out.println((Integer)enu.nextElement());

}

//toArray

Object[] objArr = vector.toArray();

System.out.println(“nobjArr:” + Arrays.asList(objArr));

Integer[] intArr = vector.toArray(new Integer[vector.size()]);

System.out.println(“intArr:” + Arrays.asList(intArr));

//add

vector.add(5);

//remove

vector.remove(5);

System.out.println(vector);

//containsAll

System.out.println(vector.containsAll(Arrays.asList(5,6)));

//addAll

vector.addAll(Arrays.asList(555,666));

System.out.println(vector);

//removeAll

vector.removeAll(Arrays.asList(555,666));

System.out.println(vector);

//addAll方法

vector.addAll(5, Arrays.asList(666,666, 6));

System.out.println(vector);

//get方法

System.out.println(vector.get(5));

//set方法

vector.set(5, 55);

System.out.println(vector.get(5));

//add方法

vector.add(0, 555);

System.out.println(vector);

//remove方法

vector.remove(0);

System.out.println(vector);

//indexof方法

System.out.println(vector.indexOf(6));

//lastIndexOf方法

System.out.println(vector.lastIndexOf(6));

//listIterator方法

ListIterator listIterator = vector.listIterator();

System.out.println(listIterator.hasPrevious());

//listIterator(index)方法

ListIterator iListIterator = vector.listIterator(5);

System.out.println(iListIterator.previous());

//subList方法

System.out.println(vector.subList(5, 7));

//clear

vector.clear();

System.out.println(vector);

}

List接口实现类Stack 栈类，是Java2之前引入的，继承自类Vector。同样是线程同步的 [html] view plain copy public class StackTest {

public static void main(String[] args){

Stack stack = new Stack();

for(int i = 0;i < 10;i++){

stack.add(i);

}

System.out.println(stack);

System.out.println(stack.peek());

stack.push(555);

System.out.println(stack);

System.out.println(stack.pop());

System.out.println(stack);

System.out.println(stack.empty());

System.out.println(stack.search(6));

System.out.println(“stack遍历：”);

while(!stack.empty()){

System.out.print(stack.pop()+ “ ”);

}

List接口总结：实际使用中我们需要根据特定的需求选用合适的类，如果除了在末尾外不能在其他位置插入或者删除元素，那么ArrayList效率更高，如果需要经常插入或者删除元素，就选择LinkedList。

Set接口实现类HashSet：

HashSet是Set接口最常见的实现类，其底层是基于hash算法进行存储相关元素的。HashSet中存储元素的位置是固定的（由hashCode决定），并且是无序的。Set集合中的去重和hashCode与equals方法相关。[html] view plain copy public class Num implements Comparable{

private int num;

public Num(int num){

this.num=num;

}

@Override

public int compareTo(Object o){

// TODO Auto-generated method stub

Num x=(Num)o;

if(num>x.num)return 1;

else if(num==x.num)return 0;

else return-1;

}

public String toString(){

return “num=”+num;

}

[html] view plain copy public class HashSetTest {

public static void main(String[] args){

Set hashSet=new HashSet();

hashSet.add(“hello”);

hashSet.add(“world”);

//使用数组的方法遍历HashSet集合String[] strArray=new String[hashSet.size()];

strArray=hashSet.toArray(strArray);

for(String str:strArray){

System.out.println(str);

}

//使用HashSet集合直接遍历

for(String str:hashSet){

System.out.println(str);

}

//用迭代器遍历HashSet集合Iterator iterator=hashSet.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

//无重写hashCode跟equals方法的类，不会自动根据类中的值进行去重

Set set2=new HashSet();

set2.add(new Num(1));

set2.add(new Num(3));

set2.add(new Num(2));

set2.add(new Num(3));

set2.add(new Num(6));

System.out.println(set2.size());

Iterator iterator2=set2.iterator();

while(iterator2.hasNext()){

System.out.println(iterator2.next());

}

Set接口实现类LinkedHashSet: LinkedHashSet继承HashSet,是用一个链表实现来扩展HashSet类，它支持对规则集内的元素排序。HashSet中的元素是没有被排序的，而LinkedHashSet中的元素可以按照它们插入规则集的顺序提取。[html] view plain copy public class LinkedHashSetTest {

public static void main(String[] args){

Set linkedHashSet=new LinkedHashSet();

linkedHashSet.add(“hello”);

linkedHashSet.add(“world”);

//使用数组的方法遍历HashSet集合String[] strArray=new String[linkedHashSet.size()];

strArray=linkedHashSet.toArray(strArray);

for(String str:strArray){

System.out.println(str);

}

//使用HashSet集合直接遍历

for(String str:linkedHashSet){

System.out.println(str);

}

//用迭代器遍历HashSet集合Iterator iterator=linkedHashSet.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

Set接口实现类TreeSet：

TreeSet实现了Set接口，它与HashSet的区别主要在于TreeSet中的元素会按照相关的值进行排序。HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key。由于TreeMap需要排序,所以需要一个Comparator为键值进行大小比较.当然也是用Comparator定位的.如果创建时没有确定,那么就会使用key.compareTo()方法,这就要求key必须实现Comparable接口.TreeMap是使用Tree数据结构实现的,所以使用compare接口就可以完成定位了.注意：TreeSet是根据对象的CompareTo方法来去重的，如果CompaerTo返回0说明两个对象相等，不能同时存在于TreeSet中。

[html] view plain copy public class TreeSetTest {

public static void main(String[] args){

Set treeSet=new TreeSet();

treeSet.add(“d”);

treeSet.add(“c”);

treeSet.add(“b”);

treeSet.add(“a”);

//String实体类中实现Comparable接口，所以在初始化TreeSet的时候， //无需传入比较器

Iterator iterator=treeSet.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

Set treeSet2=new TreeSet();

treeSet2.add(new Num(1));

treeSet2.add(new Num(3));

treeSet2.add(new Num(2));

treeSet2.add(new Num(3));

treeSet2.add(new Num(6));

System.out.println(treeSet2.size());

Iterator iterator2=treeSet2.iterator();

while(iterator2.hasNext())

{

System.out.println(iterator2.next());

}

TreeSet set = new TreeSet<>();

set.add(1111);

set.add(2222);

set.add(3333);

set.add(4444);

set.add(5555);

System.out.println(set.first());// 输出第一个元素

System.out.println(set.lower(3333));//小于3333的最大元素

System.out.println(set.higher(2222));//大于2222的最大元素

System.out.println(set.floor(3333));//不大于3333的最大元素

System.out.println(set.ceiling(3333));//不小于3333的最大元素

System.out.println(set.pollFirst());//删除第一个元素

System.out.println(set.pollLast());//删除最后一个元素

System.out.println(set);

}

Set接口区别于List接口在于：

所有Set中的元素实现了不重复，有点像数学中集合的概念，无序，不允许有重复的元素，最多允许有一个null元素对象

Map接口：

Map接口储存一组成对的键-值对象，提供key（键）到value（值）的映射，Map中的key不要求有序，不允许重复。value同样不要求有序，但可以重复。

Map实现类HashMap 最常见的Map实现类，他的储存方式是哈希表，优点是查询指定元素效率高。HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当链表中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

无论什么情况HashMap中哈希表的容量总是2的n次方的一个数。并且有这样一个公式：当length=2^n时，hashcode &(length-1)== hashcode % length

HashMap与Hashtable的区别：

Hashtable实现Map接口，继承自古老的Dictionary类，实现一个key-value的键值映射表。任何非空的（key-value）均可以放入其中。区别主要有三点： 1.Hashtable是基于陈旧的Dictionary实现的，而HashMap是基于Java1.2引进的Map接口实现的；

2.Hashtable是线程安全的，而HashMap是非线程安全的，我们可以使用外部同步的方法解决这个问题。

3.HashMap可以允许你在列表中放一个key值为null的元素，并且可以有任意多value为null，而Hashtable不允许键或者值为null。

[html] view plain copy public class HashMapTest {

public static void main(String[] args){

Map hashMap=new HashMap();

hashMap.put(“a”,1);

hashMap.put(“b”,2);

hashMap.put(“JAVA”,3);

System.out.println(hashMap.get(“JAVA”));

//第一种遍历方法：普遍使用，二次取值

for(String key : hashMap.keySet()){

System.out.println(“key= ”+ key + “ and value= ” + hashMap.get(key));

}

//第二种:通过Map.entrySet使用iterator遍历key和value

Iterator> iter=hashMap.entrySet().iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

//第三种：通过Map.entrySet遍历key和value.推荐，尤其是容量大时

for(Map.Entry entry : hashMap.entrySet()){

System.out.println(“key= ” + entry.getKey()+ “ and value= ” + entry.getValue());

}

//第四种:通过Map.values()遍历所有的value，但不能遍历key

for(Integer v : hashMap.values()){

System.out.println(“value= ” + v);

}

Map实现类LinkedHashMap LinkedHashMap继承自HashMap，它主要是用链表实现来扩展HashMap类，HshMap中条目是没有顺序的,但是在LinkedHashMap中元素既可以按照它们插入图的顺序排序，也可以按它们最后一次被访问的顺序排序。LinkedHashMap继承自HashMap并且实现了Map接口。和HashMap一样，LinkedHashMap 允许key和value均为null。于该数据结构和HashMap一样使用到hash算法，因此它不能保证映射的顺序，尤其是不能保证顺序持久不变（再哈希）。

[html] view plain copy public class LinkedHashMapTest {

public static void main(String[] args){

Map linkedHashMap=new LinkedHashMap();

linkedHashMap.put(“a”, 1);

linkedHashMap.put(“java”,2);

linkedHashMap.put(“C”, 3);

System.out.println(linkedHashMap.get(“a”));

Set> entry=linkedHashMap.entrySet();

Iterator> iter=entry.iterator();

while(iter.hasn(String[] args){

Map treeMap=new TreeMap();

treeMap.put(“b”,2);

treeMap.put(“a”,1);

treeMap.put(“e”,5);

treeMap.put(“d”,4);

treeMap.put(“c”,3);

Set> entry=treeMap.entrySet();

Iterator> iter=entry.iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

Set keySet=treeMap.keySet();

for(String x:keySet){

System.out.println(x+“=”+treeMap.get(x));

}

Map treeMap2=new TreeMap();

treeMap2.put(new Num(2),“a”);

treeMap2.put(new Num(1),“b”);

treeMap2.put(new Num(5),“c”);

treeMap2.put(new Num(4),“d”);

treeMap2.put(new Num(3),“c”);

Set keySet2=treeMap2.keySet();//根据compareTo方法去重

for(Num x:keySet2){

System.out.println(x+“=”+treeMap2.get(x));

}

//根据value排序

Map map = new HashMap();

map.put(“d”, 2);

map.put(“c”, 1);

map.put(“b”, 4);

map.put(“a”, 3);

List> infoIds =

new ArrayList>(map.entrySet());

//排序前

for(int i = 0;i < infoIds.size();i++){

String id = infoIds.get(i).toString();

System.out.println(id);

}

//排序

Collections.sort(infoIds, new Comparator>(){

public int compare(Map.Entry o1, Map.Entry o2){

return(o2.getValue()-o1.getValue());

//return(o1.getKey()).toString().compareTo(o2.getKey());

}

});

//排序后

for(int i = 0;i < infoIds.size();i++){

String id = infoIds.get(i).toString();

System.out.println(id);

}

篇3：java各种开发框架总结

关键词：Java语言；EJB组件技术；信息管理系统

中图分类号：TP311.52

信息管理系统（IMS，Information Management System）是随着计算机技术而兴起的一门学科，它综合了计算机、网络通信和数据库等多种技术，已被广泛应用于办公自动化系统、通信系统、交易处理系统、管理信息系统和执行信息系统、决策支持系统及企业系统，对于信息管理过程中的信息收集与处理、市场模拟与预测、生产计划与控制及辅助决策环节发挥着重要作用[1]。

目前，越来越多的企业或机构开始使用信息管理系统，但由于其具体业务和管理内容的不同，各机构需要完全重新设计并开发其系统。事实上，不同机构用到的信息管理系统在功能模块及逻辑架构上是相同的。如果能够将这些共性架构抽象出来，提炼成功能模块完善、逻辑层次分明的信息管理系统开发框架，各机构只需根据其具体使用场景选择模块并添加具体功能，并做必要的扩展即可。这样节省了大量的系统设计与开发工作，降低了系统开发成本，缩短了开发周期，并提高了开发效率。

1 Java与EJB介绍

1.1 Java语言。为了使本文设计的框架能够方便地移植和扩展到不同的信息管理系统中，我们需要选择移植性、扩展性和健壮性好的开发语言。因此，Java以其卓越的通用性、高效性、平台移植性和安全性成为我们的首选[2]。

Java是由Sun Microsystems公司推出的程序设计语言，Sun公司对Java编程语言的解释是：Java编程语言是个简单的、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言。Java是运行在Java虚拟机上的，只要安装了虚拟机系统，Java可以运行在任何系统下，因此，Java语言可移植性好，与平台无关。因此，我们选择Java作为本文系统开发框架语言。

1.2 EJB组件技术。为了满足信息管理系统的可扩展性，系统的各框架之间应该是一种松耦合关系，这样各部分是相对独立的，替换或修改其中某一部分对整个系统不会产生大的影响，能够方便各机构根据实际需要设计其系统。因此，我们采用组件式的体系结构，整个系统由不同的组件构成，通过对组件的添加、修改和删除即可实现对系统的设计。目前，常用的组件技术有CORBA、COM和EJB，其中EJB（Enterprise JavaBean）是Sun公司的JavaEE服务器端组件模型，我们选择EJB作为本系统的底层组件技术[3]。

EJB是一种分布式的组件技术，设计目标与核心应用是部署分布式应用程序。凭借java跨平台的优势，用EJB技术部署的分布式系统可以不限于特定的平台。EJB更关注于业务逻辑的实现而非底层的实现机制，它能够支持事务处理，可以通过在代码外的描述来定义事务处理级别可扩展性，并且提供了负载均衡，由EJB服务器提供资源的访问权限控制。

2 信息管理系统框架的设计

通过对各机构的信息管理系统的调查与分析，我们整理了系统所需的主要功能：第一，模块管理功能：用于搭建具体的信息管理系统架构，包括确定该系统所需的各个功能模块，添加、修改和删除各个模块的具体功能等。第二，业务管理功能：用于确定各模块的具体实现业务、业务流程、逻辑实现等细节。第三，用户管理功能：用于管理信息管理系统用户的使用权限，包括增加、删除用户，增加、删除角色权限，为用户添加、删除角色授权等。

基于以上功能，我们将信息管理系统设计为五层层次结构[4]，从底向上分别是：数据库层、Entity Bean层、Session Bean层、服务器层和浏览器层，如图1所示。其中，数据库层主要负责数据的存储；Entity Bean层通过JDBC接口访问数据库，其主要任务是对数据库层的封装，用来隐藏不同数据库层细节，为上层提供统一透明的访问接口；Session Bean层是远程服务器访问系统内部结构的接口，它控制所有对系统内核的访问都通过这一唯一入口；服务器层是主要的业务与数据处理中枢，负责处理系统内核提供的各类数据，并将结果通过HTTP提供给浏览器层；浏览器层是面向用户的接口，为用户呈现了可视化的业务和数据处理结果。

3 信息管理系统框架的实现

我们对信息管理系统框架的实现主要集中在Entity Bean层和Session Bean层，这两层共包括三个EJB组件：ModuleEJB、BusinessEJB、UserEJB和四个管理模块：模块管理、权限管理、用户管理和角色管理。

3.1 ModuleEJB的实现。ModuleEJB主要包括模块管理和权限管理两部分。系统开发人员在设计信息管理系统时，需首先确定该系统涉及的各个模块、各模块的功能、允许访问该模块的角色及具体的角色权限。然后，根据设计好的模块框架，添加各模块的逻辑实现流程及数据库表，其数据库表包含了模块内部的数据关系、模块与角色关系及角色与权限关系表。这样，ModuleEJB实现了对系统中各模块的管理。

3.2 BusinessEJB的实现。BusinessEJB主要包括用户管理和权限管理两部分。对于某一业务流，首先要规定哪些用户有权限执行这一操作，其次要明确不同的用户有何不同的权限。例如，企业员工有权利更改自己的个人信息，但无权更改自己的工作职责信息，而只有系统管理员可以更改员工的工作职责信息。只有明確各业务的权限归属，才能充分定义系统不同用户的职责，报障系统与企业的有效运作。

3.3 UserEJB的实现。UserEJB主要包括用户管理和角色管理两部分。我们在系统中首先规定几类不同的角色，如管理员、部门经理、主管、员工等，不同的角色分别对应不同的权限。然后，我们将用户添加到其对应的角色中，这样能够实现对用户权限的统一管理，既减少了权限划分的工作量，又能保证权限划分的统一和准确。要注意的是，不同的角色权限可能是相互嵌套的，同一用户可能被分有几个不同角色。

4 结束语

本文基于Java语言和EJB组件技术设计了信息管理系统的开发框架，该框架包括模块管理、业务管理和用户管理三大功能，从底向上分为数据库层、Entity Bean层、Session Bean层、服务器层和浏览器层共五层结构。该系统能够辅助各机构更简单、更高效地完成其信息管理系统设计与实现，且稳定运行、安全可靠。

参考文献：

[1]李瑜，黄必清，吴澄.虚拟企业信息管理系统[J].高技术通讯，2000（09）.

[2]孟祥武.Java技术简介[J].现代科学仪器，1998（04）.

[3]王子君，范学峰.EJB技术的探讨与研究[J].计算机工程，2002（02）：106-108.

[4]王强兵，刘广钟.基于J2EE的Web企业计算[J].计算机工程，2002（01）.

作者简介：刘建（1979.04-），男，广东东莞人，讲师，大学本科，软件工程硕士，研究方向：计算机科学技术。

篇4：Java XML的开发技巧总结

DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而 DOM 被认为是基于树或基于对象的。DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单得多。

另一方面，对于特别大的文档，解析和加载整个文档可能很慢且很耗资源，因此使用其他手段来处理这样的数据会更好。这些基于事件的模型，比如 SAX。

Bean文件：

package com.test;

import java.io.*;

import java.util.*;

import org.w3c.dom.*;

import javax.xml.parsers.*;

public class MyXMLReader{

public static void main(String arge[]){

long lasting =System.currentTimeMillis();

try{

File f=new File(“data_10k.xml”);

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document doc = builder.parse(f);

NodeList nl = doc.getElementsByTagName(“VALUE”);

for(int i=0;i＜nl.getLength();i++){

System.out.print(“车牌号码:” + doc.getElementsByTagName(“NO”).item(i).getFirstChild().getNodeValue());

System.out.println(“ 车主地址:” + doc.getElementsByTagName(“ADDR”).item(i).getFirstChild().getNodeValue());

}

}catch(Exception e){

e.printStackTrace();

}

System.out.println(“运行时间：”+(System.currentTimeMillis()lasting)+ “ 毫秒”);

}

public void characters(char ch[], int start, int length)throws SAXException {

String tag =(String)tags.peek();

if(tag.equals(“NO”)){

System.out.print(“车牌号码：” + new String(ch, start, length));

}

if(tag.equals(“ADDR”)){

System.out.println(“ 地址:” + new String(ch, start, length));

}

public void startElement（String uri，String localName，String qName，Attributes attrs){

tags.push(qName);

}

10k消耗时间：110 47 109 78

100k消耗时间：344 406 375 422

1000k消耗时间：3234 3281 3688 3312

10000k消耗时间：32578 34313 31797 31890 30328

然后是 JDOM http:///

JDOM 的目的是成为 Java 特定文档模型，它简化与 XML 的交互并且比使用 DOM 实现更快。由于是第一个 Java 特定模型，JDOM 一直得到大力推广和促进。正在考虑通过“Java 规范请求 JSR-102”将它最终用作“Java 标准扩展”。从 2000 年初就已经开始了 JDOM 开发。

JDOM 与 DOM 主要有两方面不同。首先，JDOM 仅使用具体类而不使用接口。这在某些方面简化了 API，但是也限制了灵活性。第二，API 大量使用了 Collections 类，简化了那些已经熟悉这些类的 Java 开发者的使用。

JDOM 文档声明其目的是“使用 20%（或更少）的精力解决 80%（或更多）Java/XML 问题”（根据学习曲线假定为 20%）。JDOM 对于大多数 Java/XML 应用程序来说当然是有用的，并且大多数开发者发现 API 比 DOM 容易理解得多。JDOM 还包括对程序行为的相当广泛检查以防止用户做任何在 XML 中无意义的事。然而，它仍需要您充分理解 XML 以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。这也许是比学习DOM 或 JDOM 接口都更有意义的工作。

JDOM 自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档（尽管它还可以将以前构造的 DOM 表示作为输入）。它包含一些转换器以将 JDOM 表示输出成 SAX2 事件流、DOM 模型或 XML 文本文档。JDOM 是在 Apache 许可证变体下发布的开放源码。

Bean文件：

package com.test;

import java.io.*;

import java.util.*;

import org.jdom.*;

import org.jdom.input.*;

public class MyXMLReader {

public static void main(String arge[]){

long lasting = System.currentTimeMillis();

try {

SAXBuilder builder = new SAXBuilder();

Document doc = builder.build(new File(“data_10k.xml”));

Element foo = doc.getRootElement();

List allChildren = foo.getChildren();

for(int i=0;i＜allChildren.size();i++){

System.out.print(“车牌号码:” +((Element)allChildren.get(i)).getChild(“NO”).getText());

System.out.println(“ 车主地址:” +((Element)allChildren.get(i)).getChild(“ADDR”).getText());

}

} catch(Exception e){

e.printStackTrace();

}

System.out.println(“运行时间：” +(System.currentTimeMillis()lasting)+ “ 毫秒”);

}

10k消耗时间：109 78 109 31

100k消耗时间：297 359 172 312

1000k消耗时间：2281 2359 2344 2469

10000k消耗时间：20938 19922 20031 21078

JDOM 和 DOM 在性能测试时表现不佳，在测试 10M 文档时内存溢出。在小文档情况下还值得考虑使用 DOM 和 JDOM。虽然 JDOM 的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM 仍是一个非常好的选择。DOM 实现广泛应用于多种编程语言。它还是许多其它与 XML 相关的标准的基础，因为它正式获得 W3C 推荐（与基于非标准的 Java 模型相对），所以在某些类型的项目中可能也需要它（如在 JavaScript 中使用 DOM）。

SAX表现较好，这要依赖于它特定的解析方式。一个 SAX 检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。

篇5：java各种开发框架总结

在具体的实现中，表现层可为Struts/JSF等，业务层、访问层可为JavaBean或EJB等，资源层一般为数据库。

宏观上的层次就是这样，在具体现实中，有如下几种实现形式：

1，轻量级实现

表现层使用基于MVC的框架，比如Struts或JSF 业务层使用JavaBean（就是常说的Service）访问层使用JavaBean（就是常说的DAO）优点：

轻量级实现，简单明了 缺点：

难以无法实现分布式应用

以下功能必须通过编程实现

事务控制 资源管理（包括组件的创建）

线程安全问题

安全性

2，重量级J2EE实现

表现层依然是基于MVC的框架

访问层采用实体Bean实现，如果可能最好采用CMP，实现起来更简洁。此处的实体Bean可以考虑采用本地接口

业务层一分为二，服务控制器可以由会话Bean充当，用来封装业务流程（相当于轻量级实现中的Service），也可以考虑采用本地接口；门面也可以由会话Bean充当（一般来说无状态会话Bean足矣），作为业务层的入口，应该采用远程接口。优点：

以下功能可由EJB容器自动实现，或通过配置实现

事务控制

远程访问

线程安全

资源管理

安全性

可以进行分布式应用

因为采用了EJB，故部分特征可以由装配人员来配置（比如事务，安全性等），不需要在软件中硬编码 EJB组件有更好的重用性

可利用容器提供的其他企业级的功能（比如集群，容错，灾难恢复等）

可以加入MDB（实现异步通讯）等技术 缺点：

开发难度较高

如果不恰当的使用实体Bean，会造成效率低下。如果采用CMP，则很多数据访问的操作不能直接实现。

缺少良好的开发环境

软件可能依赖于具体的EJB容器 EJB容器可能很贵，开发软件也可能很贵

3，轻量级和重量级J2EE的切换

如果项目有需求，并有充分的时间，还可以通过在表现层和业务层的交界处加入“业务代表”（JavaBean + 服务定位器实现）来对表现层隐藏对业务层访问的细节(JavaBean和EJB的访问方式显然不同)，只需替换“业务代表”就可以切换轻量级和重量级两种实现。举例说明，一般电话上都有一个P/T开关（脉冲/音频开关），随着开关状态的不同，拨号时电话机会判断是使用脉冲拨号还是音频拨号。

这种架构唯一的缺点就是必须写两套实现代码„„

4，轻量级J2EE实现

访问层通过JavaBean调用ORM框架实现（Hibernate，iBatis等），代码简洁，功能完备（相对于EJB 2.x而言），如果用的是Hibernate，可以忽略底层数据库的差异，如果用的是iBatis，则方便对SQL进行优化。

业务层和访问层依靠AOP框架（如Spring）可以在切面中实现事务，安全性等功能，同时不影响业务代码。如果采用Spring，其中已经内置了事物切面，并可以轻易的与主流ORM框架进行整合，实现声明式的事物管理。当然，更可以使用IoC模式降低组件间的耦合性。优点：

可以通过AOP框架实现事物、安全性等功能，同时不影响业务代码

ORM框架比CMP更灵活，比BMP更简洁（相对于EJB 2.x而言），运行效率也比较高

如果使用Spring，可以用更简单的方式实现J2EE中比较复杂的功能

无需额外的容器

ORM和AOP框架可以找到免费的开源实现，降低项目成本（不过也有人认为采用开源项目可能综合成本更高） 缺点：

非官方框架，缺少文档、技术支持和业界经验

采用技术太多，学习曲线较高，难以招到合适的程序员（咱们学员可以考虑在这方面下点功夫，呵呵）

某些企业级的功能轻量级框架还不能实现（或独立实现）