服务器编写java代码 服务器编写java代码命令

编写代码,使用java ServerSocket创建服务器端ServerSocket的过程。

package socket;

成都创新互联公司专业为企业提供中阳网站建设、中阳做网站、中阳网站设计、中阳网站制作等企业网站建设、网页设计与制作、中阳企业网站模板建站服务,10多年中阳做网站经验,不只是建网站,更提供有价值的思路和整体网络服务。

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class SocketService {

//搭建服务器端

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

SocketService socketService = new SocketService();

//1、a)创建一个服务器端Socket,即SocketService 

socketService.oneServer();

}

public  void oneServer(){

try{

ServerSocket server=null;

try{

server=new ServerSocket(5209);

//b)指定绑定的端口,并监听此端口。

System.out.println("服务器启动成功");

//创建一个ServerSocket在端口5209监听客户请求

}catch(Exception e) {

System.out.println("没有启动监听:"+e);

//出错,打印出错信息

}

Socket socket=null;

try{

socket=server.accept();

//2、调用accept()方法开始监听,等待客户端的连接 

//使用accept()阻塞等待客户请求,有客户

//请求到来则产生一个Socket对象,并继续执行

}catch(Exception e) {

System.out.println("Error."+e);

//出错,打印出错信息

}

//3、获取输入流,并读取客户端信息 

String line;

BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream()));

//由Socket对象得到输入流,并构造相应的BufferedReader对象

PrintWriter writer=new PrintWriter(socket.getOutputStream());

//由Socket对象得到输出流,并构造PrintWriter对象

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

//由系统标准输入设备构造BufferedReader对象

System.out.println("Client:"+in.readLine());

//在标准输出上打印从客户端读入的字符串

line=br.readLine();

//从标准输入读入一字符串

//4、获取输出流,响应客户端的请求 

while(!line.equals("end")){

//如果该字符串为 "bye",则停止循环

writer.println(line);

//向客户端输出该字符串

writer.flush();

//刷新输出流,使Client马上收到该字符串

System.out.println("Server:"+line);

//在系统标准输出上打印读入的字符串

System.out.println("Client:"+in.readLine());

//从Client读入一字符串,并打印到标准输出上

line=br.readLine();

//从系统标准输入读入一字符串

} //继续循环

//5、关闭资源 

writer.close(); //关闭Socket输出流

in.close(); //关闭Socket输入流

socket.close(); //关闭Socket

server.close(); //关闭ServerSocket

}catch(Exception e) {//出错,打印出错信息

System.out.println("Error."+e);

}

}

}

关于java,soap服务器端的代码怎么写

soapenv:Header/

soapenv:Body

api:getEmp

shopIdstring/shopId

/api:getEmp

/soapenv:Body

/soapenv:Envelope

这个时SOAP协议的标准报文格式,客户端只要发送这样的报文给支持SOAP协议的webservice服务器即可成功调用web service服务

服务端:部署服务只需要自己定义服务的接口和实现类,并用@webservice注解,通过endPoint类直接发布即可

虽能告诉我服务器端最简单的java程序?

15.3 服务多个客户

JabberServer可以正常工作,但每次只能为一个客户程序提供服务。在典型的服务器中,我们希望同时能处理多个客户的请求。解决这个问题的关键就是多线程处理机制。而对于那些本身不支持多线程的语言,达到这个要求无疑是异常困难的。通过第14章的学习,大家已经知道Java已对多线程的处理进行了尽可能的简化。由于Java的线程处理方式非常直接,所以让服务器控制多名客户并不是件难事。

最基本的方法是在服务器(程序)里创建单个ServerSocket,并调用accept()来等候一个新连接。一旦accept()返回,我们就取得结果获得的Socket,并用它新建一个线程,令其只为那个特定的客户服务。然后再调用accept(),等候下一次新的连接请求。

对于下面这段服务器代码,大家可发现它与JabberServer.java例子非常相似,只是为一个特定的客户提供服务的所有操作都已移入一个独立的线程类中:

//: MultiJabberServer.java

// A server that uses multithreading to handle

// any number of clients.

import java.io.*;

import java.net.*;

class ServeOneJabber extends Thread {

private Socket socket;

private BufferedReader in;

private PrintWriter out;

public ServeOneJabber(Socket s)

throws IOException {

socket = s;

in =

new BufferedReader(

new InputStreamReader(

socket.getInputStream()));

// Enable auto-flush:

out =

new PrintWriter(

new BufferedWriter(

new OutputStreamWriter(

socket.getOutputStream())), true);

// If any of the above calls throw an

// exception, the caller is responsible for

// closing the socket. Otherwise the thread

// will close it.

start(); // Calls run()

}

public void run() {

try {

while (true) {

String str = in.readLine();

if (str.equals("END")) break;

System.out.println("Echoing: " + str);

out.println(str);

}

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

} catch (IOException e) {

} finally {

try {

socket.close();

} catch(IOException e) {}

}

}

}

public class MultiJabberServer {

static final int PORT = 8080;

public static void main(String[] args)

throws IOException {

ServerSocket s = new ServerSocket(PORT);

System.out.println("Server Started");

try {

while(true) {

// Blocks until a connection occurs:

Socket socket = s.accept();

try {

new ServeOneJabber(socket);

} catch(IOException e) {

// If it fails, close the socket,

// otherwise the thread will close it:

socket.close();

}

}

} finally {

s.close();

}

}

} ///:~

每次有新客户请求建立一个连接时,ServeOneJabber线程都会取得由accept()在main()中生成的Socket对象。然后和往常一样,它创建一个BufferedReader,并用Socket自动刷新PrintWriter对象。最后,它调用Thread的特殊方法start(),令其进行线程的初始化,然后调用run()。这里采取的操作与前例是一样的:从套扫字读入某些东西,然后把它原样反馈回去,直到遇到一个特殊的"END"结束标志为止。

同样地,套接字的清除必须进行谨慎的设计。就目前这种情况来说,套接字是在ServeOneJabber外部创建的,所以清除工作可以“共享”。若ServeOneJabber构建器失败,那么只需向调用者“掷”出一个违例即可,然后由调用者负责线程的清除。但假如构建器成功,那么必须由ServeOneJabber对象负责线程的清除,这是在它的run()里进行的。

请注意MultiJabberServer有多么简单。和以前一样,我们创建一个ServerSocket,并调用accept()允许一个新连接的建立。但这一次,accept()的返回值(一个套接字)将传递给用于ServeOneJabber的构建器,由它创建一个新线程,并对那个连接进行控制。连接中断后,线程便可简单地消失。

如果ServerSocket创建失败,则再一次通过main()掷出违例。如果成功,则位于外层的try-finally代码块可以担保正确的清除。位于内层的try-catch块只负责防范ServeOneJabber构建器的失败;若构建器成功,则ServeOneJabber线程会将对应的套接字关掉。

为了证实服务器代码确实能为多名客户提供服务,下面这个程序将创建许多客户(使用线程),并同相同的服务器建立连接。每个线程的“存在时间”都是有限的。一旦到期,就留出空间以便创建一个新线程。允许创建的线程的最大数量是由final int maxthreads决定的。大家会注意到这个值非常关键,因为假如把它设得很大,线程便有可能耗尽资源,并产生不可预知的程序错误。

//: MultiJabberClient.java

// Client that tests the MultiJabberServer

// by starting up multiple clients.

import java.net.*;

import java.io.*;

class JabberClientThread extends Thread {

private Socket socket;

private BufferedReader in;

private PrintWriter out;

private static int counter = 0;

private int id = counter++;

private static int threadcount = 0;

public static int threadCount() {

return threadcount;

}

public JabberClientThread(InetAddress addr) {

System.out.println("Making client " + id);

threadcount++;

try {

socket =

new Socket(addr, MultiJabberServer.PORT);

} catch(IOException e) {

// If the creation of the socket fails,

// nothing needs to be cleaned up.

}

try {

in =

new BufferedReader(

new InputStreamReader(

socket.getInputStream()));

// Enable auto-flush:

out =

new PrintWriter(

new BufferedWriter(

new OutputStreamWriter(

socket.getOutputStream())), true);

start();

} catch(IOException e) {

// The socket should be closed on any

// failures other than the socket

// constructor:

try {

socket.close();

} catch(IOException e2) {}

}

// Otherwise the socket will be closed by

// the run() method of the thread.

}

public void run() {

try {

for(int i = 0; i 25; i++) {

out.println("Client " + id + ": " + i);

String str = in.readLine();

System.out.println(str);

}

out.println("END");

} catch(IOException e) {

} finally {

// Always close it:

try {

socket.close();

} catch(IOException e) {}

threadcount--; // Ending this thread

}

}

}

public class MultiJabberClient {

static final int MAX_THREADS = 40;

public static void main(String[] args)

throws IOException, InterruptedException {

InetAddress addr =

InetAddress.getByName(null);

while(true) {

if(JabberClientThread.threadCount()

MAX_THREADS)

new JabberClientThread(addr);

Thread.currentThread().sleep(100);

}

}

} ///:~

JabberClientThread构建器获取一个InetAddress,并用它打开一个套接字。大家可能已看出了这样的一个套路:Socket肯定用于创建某种Reader以及/或者Writer(或者InputStream和/或OutputStream)对象,这是运用Socket的唯一方式(当然,我们可考虑编写一、两个类,令其自动完成这些操作,避免大量重复的代码编写工作)。同样地,start()执行线程的初始化,并调用run()。在这里,消息发送给服务器,而来自服务器的信息则在屏幕上回显出来。然而,线程的“存在时间”是有限的,最终都会结束。注意在套接字创建好以后,但在构建器完成之前,假若构建器失败,套接字会被清除。否则,为套接字调用close()的责任便落到了run()方法的头上。

threadcount跟踪计算目前存在的JabberClientThread对象的数量。它将作为构建器的一部分增值,并在run()退出时减值(run()退出意味着线程中止)。在MultiJabberClient.main()中,大家可以看到线程的数量会得到检查。若数量太多,则多余的暂时不创建。方法随后进入“休眠”状态。这样一来,一旦部分线程最后被中止,多作的那些线程就可以创建了。大家可试验一下逐渐增大MAX_THREADS,看看对于你使用的系统来说,建立多少线程(连接)才会使您的系统资源降低到危险程度。

HttpPost发送字符串到服务器,服务器接收代码并显示怎么写Java代码?

服务器端接收客户端的请求的话,需要在服务器端的java文件实现HttpServlet这个接口,并且在web.xml里配置一个客户端的请求拦截。

web.xml里的代码里添加

servlet

servlet-nametestServlet/servlet-name!--这个名字可以自己定--

servlet-classcom.sun.testServlet/servlet-class!--这里是你需要接收客户端请求的那个类以及包名,也就是下面拦截到的url会转发到的那个类--

/servlet

servlet-mapping

servlet-nametestServlet/servlet-name!--和上面的name需要一样--

url-pattern/*/url-pattern!--什么类型的客户端请求会被拦截,/* 就是全拦截了--

/servlet-mapping

然后再服务器端的类文件,要实现 HttpServlet这个接口。并把doGet()方法和doPost()方法重写。

这两种方法分别对应的是客户端的get请求和post请求的处理,你的是post请求的话,就在doPost()方法内,写你的业务。

然后再用下面两句话,设置你要返回客户端的数据。

//这是设置你要返回去的数据。value才是你的数据,key是标签。

request.setAttribute("key", "value");

//这是设置你要返回去test.jsp这张页面。

request.getRequestDispatcher("test.jsp").forward(request, response);

不知道你是不是这个意思,你可以再去看看相关servlet方面的知识,

关于客户端和服务器端大概也就是有个servlet作为请求的拦截

然后经过相关判断后,选择性的传到服务器的相应类里面。

再经过类里面的业务,把得到需要的数据回传到指定的页面上。

如何部署android服务器端的java代码

Java平台般三版本:Java ME(微型版用于某些手机)、Java SE(标准版用于台式电脑)、Java EE(企业版用于服务器端应用)谈Java我通指Java SE版本包含虚拟机编译器

首先Java代码编译称字节码间格式字节码目标电脑运行虚拟机快速解析目标电脑硬件操作系统所需要本机格式

除发者提供编写处运行优势Java能通垃圾收器(GC)实现自内存管理发者免手代码释放用象内存虽功能非用且降低代码引入内存问题风险增加运行销需要停执行垃圾收进程

本文比较Java SE用于Android发Java间差异首先我介绍发者习惯Java

SE语言结构及何Android运行其我介绍何优化AndroidJava代码何优化内存配及何恰处理线程

比较AndroidDalvik JavaJava SE

虽远Android现前发者能用Java编程语言移设备编写应用程序Java功能极限版本称Java

ME(微型版)同移设备需编写同代码写应用程序能支持Java

ME任何手机运行几乎能外由于存线商店应用发布程极其复杂

Android问世发者提供构建智能手机强应用机发者需用Java编程语言及熟知标准Java

API编写代码尽管Android发者仍使用Java SE编译器编译应用程序发现James

Gosling发JavaAndroid设备Java存许同处

Android设备运行VM(虚拟机)称Dalvik初由谷歌Dan

Bornstein发适用于CPU内存受限移设备Java SEDalvik Java存些差异主要体现虚拟机Java

SE使用栈机设计Dalvik设计基于寄存器机器Android SDKdx工具Java

SE栈机器字节码转换基于寄存器Dalvik机器字节码该转换步骤由IDE自完

基于栈虚拟机基于寄存器虚拟机定义及差异列入我讨论范围由于历史原Android使用基于寄存器虚拟机虽基于寄存器虚拟机比基于栈虚拟机快32%限于执行解释字节码虚拟机(说解释型虚拟机)Android

2.2版本(称Froyo)前Dalvik虚拟机都纯解释型Froyo版本引入JIT编译器(即编译)Java

SE早优势

JIT编译称态翻译执行前字节码翻译本机代码(图1所示)主要两处首先消除些纯解释型虚拟机销;其能本机代码执行优化通静态编译代码做例JIT编译器运行CPU选择合适优化根据应用程序输入析代码何运行便进行步优化

图1 Android JavaJava SE翻译步骤

虽AndroidDalvik JIT编译器发展前景要达Java SEJIT编译器般稳定、熟度尚需段间Dalvik JIT现Android提供巨性能优势且断改善

JAVA

SE虚拟机Dalvik虚拟机另区别者进行优化运行同机器实例机启叫做zygote进程该进程创建第Dalvik实例由实例创建所其实例应用程序启zygote进程收创建新虚拟机实例请求并给该应用程序创建新进程(图2所示)发者已习惯于Java

SE发设计能看起切实际优势避免由应用程序运行失败导致Dalvik虚拟机崩溃继引发应用程序崩溃

图2 Android启新Dalvik虚拟机实例

AndroidJava

SE除运行虚拟机同外实现API式Android属于javajavax包API都自Apache

Harmony(源项目旨重新实现Java SE软件栈该项目201111月再维护)发面些APIJava

SE包类似存些差别例谷歌HttpUrlConnection类进行Java SE版本所没重升级

外Android平台移除Java

SE关API例Swing/AWT包完全移除Android使用同UI框架其移除APIRMI、CORBA、ImageIOJMX或者替换特定Android版本(android包空间内)或者些实际原根本存

优化AndroidJava代码

经改进Java

SE具备些简化编写复杂代码结构新特性其些特性让整流程变更简单发者需要解何及何确使用另外由于Java

SE用于服务器端发(使用Java企业版API)发员专门服务器端Java代码进行优化注解Java虚拟机脚本语言支持服务器端发进行优化例证虽些工具构建端发强发Android客户端代码些特性作用甚至起反作用Java发者已经习惯于限量RAMCPUAndroid发需要密切关注性能内存配简单说发者需要使用稍微同待Android端发

随着Android首发布情况所改变曾经些Android尽量用Java规范重新推荐主要Android目前JIT编译器解决些规范导致性能问题

本文讨论编写Android应用程序需要解Java代码我深究Java编程语言细节重点关注Android发重要东西发者仍需解数适用于Java SE规则建议同适用于AndroidDalvik虚拟机

Android类型安全枚举

Java SE 5.0新增许便发者新特性其值期待引入类型安全枚举枚举代码用表示属于某组几选择早期版本Java用整型量解决问题虽技术行容易错请看面代码:

public class Machine {

public static final int STOPPED = 10;

public static final int INITIALIZING = 20;

public static final int STARTING = 30;

public static final int RUNNING = 40;

public static final int STOPPING = 50;

public static final int CRASHED = 60;

private int mState;

public Machine() {

mState = STOPPED;

}

public int getState() {

return mState;

}

public void setState(int state) {

mState = state;

}

}

问题虽些量期望没机制保证setState()接收同值要设置添加检查旦非预期值发者需要处理错误发者所需要编译检查非赋值类型安全枚举解决问题所示:

public class Machine {

public enum State {

STOPPED, INITIALIZING, STARTING, RUNNING, STOPPING, CRASHED

}

private State mState;

public Machine() {

mState = State.STOPPED;

}

public State getState() {

return mState;

}

public void setState(State state) {

mState = state;

}

}

注意声明同类型安全值新加内部枚举类编译解决非赋值问题所代码更容易错

Dalvik虚拟机没JIT编译器优化代码建议Android平台使用枚举类型使用整型量相比种设计带内存性能损失更些版本Android

API存整型量原今更强JIT编译器及断改进Dalvik虚拟机发者必再担问题放胆使用类型安全枚举即

仍存些情况使用整型量更选择像intJava基本类型增加GC销外Android SDK许已API仍依赖基本类型比Handler类——种情况没太选择

Android增强版for循环

Java SE 5.0引入增强版for循环提供通用缩写表达式遍历集合数组首先比较五种:

void loopOne(String[] names) {

int size = names.length;

for (int i = 0; i size; i++) {

printName(names[i]);

}

}

void loopTwo(String[] names) {

for (String name : names) {

printName(name);

}

}

void loopThree(Collection names) {

for (String name : names) {

printName(name);

}

}

void loopFour(Collection names) {

Iterator iterator = names.iterator();

while (iterator.hasNext()) {

printName(iterator.next());

}

}

// 要ArrayList使用增强版for循环

void loopFive(ArrayList names) {

int size = names.size();

for (int i = 0; i size; i++) {

printName(names.get(i));

}

}

面显示四种同遍历集合数组式前面两种着相同性能所读取元素放数组使用增强版for循环Collection象说增强版for循环使用迭代器遍历元素着相同性能ArrayList象应避免使用增强版for循环

仅需要遍历元素且需要元素位置定要使用数组或者ArrayList所其Collection类些情况更慢

般情况读取元素几乎变数据集性能要求高建议使用规数组数组固定添加数据影响性能所编写代码要考虑所素

队列、同步锁

通情况应用程序线程产数据另线程使用见例线程获取网络数据另线程(操作UI主线程)些数据展现给用户种模式称产者/消费者模式面向象编程课程发者用算实现该模式能要花几面介绍些简化产者/消费者模式实现现类

1. 更智能队列

虽已现类并能用更少代码实现该功能许Java发者仍选择使用LinkedList及同步块实现队列功能发者java.util.concurrent包找同步相关类外本包包含信号量、锁及单变量进行原操作类考虑面使用标准LinkedList实现线程安全队列代码

public class ThreadSafeQueue {

private LinkedList mList = new LinkedList();

private final Object mLock = new Object();

public void offer(String value) {

synchronized (mLock) {

mList.offer(value);

mLock.notifyAll();

}

}

public synchronized String poll() {

synchronized (mLock) {

while (mList.isEmpty()) {

try {

mLock.wait();

} catch (InterruptedException e) {

//简洁起见忽略异处理

}

}

return mList.poll();

}

}

}

虽段代码确并能考试满实现测试段代码浪费间实际所前面代码用面行代替

LinkedBlockingQueue blockingQueue =

new LinkedBlockingQueue();

面行代码能像前面例提供相同类型阻塞队列甚至能提供额外线程安全操作java.util.concurrent包含许选队列及并发映射类所般情况建议使用像前示例使用更代码

2. 更智能锁

Java提供synchronized关键字允许发者创建线程安全代码块synchronized关键字易于使用容易滥用性能造负面影响需要区读数据写数据synchronized关键字并效幸java.util.concurrent.locks包工具类种情况提供支持

public class ReadWriteLockDemo {

private final ReentrantReadWriteLock mLock;

private String mName;

private int mAge;

private String mAddress;

public ReadWriteLockDemo() {

mLock = new ReentrantReadWriteLock();

}

public void setPersonData(String name, int age, String address) {

ReentrantReadWriteLock.WriteLock writeLock = mLock.writeLock();

try {

writeLock.lock();

mName = name;

mAge = age;

mAddress = address;

} finally {

writeLock.unlock();

}

}

public String getName() {

ReentrantReadWriteLock.ReadLock readLock = mLock.readLock();

try {

readLock.lock();

return mName;

} finally {

readLock.unlock();

}

}

// 重复代码再赘述

}

面代码展示使用ReentrantReadWriteLock允许并发线程数据进行读访问并确保同间线程写入相同数据

代码使用synchronized关键字仍处理锁问题效论何种情况都要考虑ReentrantReadWriteLock否

高手帮忙写个JAVA的程序,是关于服务器的

注:以下代码,除FileFilter是编译并测试过的,其它代码未在IDE中编写,所以可能会有问题,自己试下

String dirname = "d:\\abc";

File dir = new File(dirname);

String suffix = ".abc";

String dst = ".def";

File[] files = dir.list(new FileFilter(suffix, false);

for (File file : files) {

String newName = file.getAbsolutePath().replace(suffix, dst);

file.renameTo(new File(newName));

}

/**

* p标题: FileFilter./p

*

* p描述: 文件过滤器/p

*

* p版权: Copyright (c) 2006/p

*

* @author BlazeCrystal

*

* @version 1.0.0

*/

public class FileFilter implements java.io.FileFilter {

public static final int ALL = 0;

public static final int ONLY_DIR = 1;

public static final int ONLY_FILE = 2;

/**

* 过滤器.

*/

private String nameFilter;

/**

* 是否大小写敏感.

*/

private boolean capSense;

/**

* 类型过滤器.

*/

private int typeFilter;

/**

*

* 构造函数.

*

* @param nameFilter String 名称过滤器

* @param capSense boolean 是否大小写敏感

*/

public FileFilter(String nameFilter, boolean capSense) {

this.capSense = capSense;

if (this.capSense) {

this.nameFilter = nameFilter;

} else {

this.nameFilter = nameFilter.toLowerCase();

}

this.typeFilter = ALL;

}

/**

*

* 构造函数.

*

* @param nameFilter String 名称过滤器

* @param capSense boolean 是否大小写敏感

* @param typeFilter int 类型过滤器

*/

public FileFilter(String nameFilter, boolean capSense, int typeFilter) {

this.capSense = capSense;

if (this.capSense) {

this.nameFilter = nameFilter;

} else {

this.nameFilter = nameFilter.toLowerCase();

}

this.typeFilter = typeFilter;

}

/**

*

* 构造函数.

*

* @param typeFilter int 类型过滤器

*/

public FileFilter(int typeFilter) {

this.typeFilter = typeFilter;

}

/**

* 过滤.

*

* @param file File 当前文件

* @return boolean 是否应选择

*/

public boolean accept(File file) {

boolean accept = true;

if (this.typeFilter != 0) {

accept = filterByType(file);

}

if (!StringUtils.isEmpty(this.nameFilter)) {

accept = filterByName(file);

}

return accept;

}

/**

* 用名称过滤.

*

* @param file File 文件

* @return boolean 是否保留

*/

public boolean filterByName(File file) {

String temp = null;

if (this.capSense) {

temp = file.getName();

} else {

temp = file.getName().toLowerCase();

}

if (temp.indexOf(this.nameFilter) -1) {

return true;

}

return false;

}

/**

* 用类型过滤.

*

* @param file File 当前文件

* @return boolean 是否保留

*/

public boolean filterByType(File file) {

switch (this.typeFilter) {

case ONLY_DIR:

return file.isDirectory();

case ONLY_FILE:

return file.isFile();

default:

return true;

}

}

/**

* 获得nameFilter.

*

* @return nameFilter

*/

public String getNameFilter() {

return nameFilter;

}

/**

* 设置nameFilter.

*

* @param nameFilter 要设置的 nameFilter

*/

public void setNameFilter(String nameFilter) {

this.nameFilter = nameFilter;

}

/**

* 获得capSense.

*

* @return capSense

*/

public boolean isCapSense() {

return capSense;

}

/**

* 设置capSense.

*

* @param capSense 要设置的 capSense

*/

public void setCapSense(boolean capSense) {

this.capSense = capSense;

}

/**

* 获得typeFilter.

*

* @return typeFilter

*/

public int getTypeFilter() {

return typeFilter;

}

/**

* 设置typeFilter.

*

* @param typeFilter 要设置的 typeFilter

*/

public void setTypeFilter(int typeFilter) {

this.typeFilter = typeFilter;

}

}


名称栏目:服务器编写java代码 服务器编写java代码命令
转载源于:http://scyanting.com/article/doopocc.html