package day05.chat;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 服务端应用程序
* @author Administrator
*
*/
public class Server {
//ServerSocket运行在服务端的Socket
private ServerSocket server;
//保存所有客户端输出流的集合，用于共享以便广播
private List<PrintWriter> allOut;
//线程池
private ExecutorService threadPool;
/**
* 构造方法，用于初始化服务端
*/
public Server(){
try {
server = new ServerSocket(Config.getKeyToInt("server_port"));
allOut = new ArrayList<PrintWriter>();
threadPool = Executors.newFixedThreadPool(40);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 向共享集合中添加一个客户端的输出流
* @param pw
*/
public synchronized void addOut(PrintWriter pw){
allOut.add(pw);
}
/**
* 将给定的客户端的输出流从共享集合中删除
* @param pw
*/
public synchronized void removeOut(PrintWriter pw){
allOut.remove(pw);
}
/**
* 将给定的消息转发给所有的客户端
* @param message
*/
public synchronized void sendMessageToAllClient(String message){
for(PrintWriter pw : allOut){
pw.println(message);
}
}
/**
* 启动服务端的方法
*/
public void start(){
try {
//监听8088端口，等待客户端的连接
/*
* accept方法是一个阻塞方法，直到一个客户端
* 连接，该方法会返回针对该客户端的Socket
* 也就是说，通过这个Socket就可以与连接上
* 的客户端进行交互了
*/
while(true){
System.out.println("等待客户端连接...");
Socket socket = server.accept();
System.out.println("客户端连接了.");
/*
* 当一个客户端连接后，
* 启动一个线程(ClientHandler),将连接的
* 客户端的Socket传入。
*/
ClientHandler handler
= new ClientHandler(socket);
//创建线程，指派任务并启动
// Thread thread = new Thread(handler);
// thread.start();
//将任务交给线程池
threadPool.execute(handler);
}
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
Server server = new Server();
server.start();
}
/**
* Server用于处理不同客户端的多线程任务。
* 该类主要负责与给定的客户端进行交互
* @author Administrator
*
*/
class ClientHandler implements Runnable{
//用于交互的客户端Socket
private Socket socket;
/**
* 构造该线程任务的同时要求指派需要交互的
* 客户端的Socket
* @param socket
*/
public ClientHandler(Socket socket){
this.socket = socket;
}
public void run() {
//定义在try外面，保证finally可以关闭它
PrintWriter pw = null;
try {
/*
* 线程启动后，我们首先获取该客户端的
* 输出流，将其放入共享集合。
*/
OutputStream out
= socket.getOutputStream();
OutputStreamWriter osw
= new OutputStreamWriter(out,"UTF-8");
pw = new PrintWriter(osw,true);
//将该客户端的输出流存入共享集合
addOut(pw);
/*
* 输出当前在线人数:
* 思路：
* 保存所有输出流的集合中有多少元素
* 就说明有多少个用户，所以我们直接
* 输出集合的元素数量即可
*/
System.out.println(
"当前在线人数:"+allOut.size());
//获取远端(客户端)的信息
InetAddress inet
= socket.getInetAddress();
System.out.println(
"客户端端口:"+socket.getPort());
System.out.println(
"客户端完全限定名:"+inet.getCanonicalHostName());
/*
* 服务端这边我们通过该客户端的Socket
* 获取输入流，来读取客户端发送过来的
* 信息
*/
//java.io.InputStream
InputStream in
= socket.getInputStream();
InputStreamReader isr
= new InputStreamReader(in,"UTF-8");
BufferedReader br
= new BufferedReader(isr);
/*
* windows与linux的差异
* 对于客户端主动断开连接后
* windows通过输入流读取数据时会
* 抛出异常。
* br.readLine()//抛出异常
*
* linux则通过输入流读取数据时获取null
* br.readLine()//返回值为null
* 对于缓冲字符输入流的readLine方法
* 若返回值为null，表示任何数据可读了
*/
String line = null;
/*
* 第一次读取到的用户输入的信息是
* 该用户的昵称
*/
String nickName = br.readLine();
while((line = br.readLine()) != null){
// System.out.println(
// "客户端说:"+br.readLine());
/*
* 每当读取到客户端发送过来的消息后
* 就广播给所有客户端
*/
sendMessageToAllClient(nickName+"说:"+line);
}
} catch (Exception e) {
} finally{
/*
* 无论是否正常交互完毕，最终都要与该
* 客户端断开连接
*/
try {
/*
* 首先，当服务端要与客户端断开连接
* 前，先将该客户端的输出流从共享
* 集合中删除，这样，后续的消息就不用0
* 转发给该客户端了。
*/
removeOut(pw);
/*
* 当一个客户端下线后，同样输出
* 当前在线人数
*/
System.out.println(
"当前在线人数:"+allOut.size());
/*
* 关闭Socket那么通过该Socket
* 获取的输入与输出流就全部关闭
* 了
*/
socket.close();
} catch (IOException e) {
}
}
}
}
}

package day05.chat;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Properties;
import java.util.Scanner;
/**
* 客户端应用程序
* @author Administrator
*
*/
public class Client {
//运行在客户端的Socket，使用它来连接服务端
private Socket socket;
/**
* 构造方法，用于初始化客户端
*/
public Client(){
try {
//获取服务端的地址
String host
=Config.getKeyToString("server_host");
int port
= Config.getKeyToInt("server_port");
System.out.println("服务器的ip:"+host);
System.out.println("服务器的端口:"+port);
/*
* /sbin/ifconfig
* 创建Socket的同时就发起了连接。
* 连接若不成功，则会抛出异常
*/
socket = new Socket(host,port);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 客户端的启动方法
*/
public void start(){
try {
/*
* 客户端启动后，我们先启动线程来接收
* 服务端发送过来的信息。
*/
GetMessageHandler handler
= new GetMessageHandler();
Thread t = new Thread(handler);
/*
* 将获取服务端消息的线程设置为后台线程
* 这样当我们停止了向服务端发送信息的线程
* 后，该线程会一同结束。
*/
t.setDaemon(true);
t.start();
/**
* 获取用于与服务端发送信息的输出流
*/
//java.io.OutputStream
OutputStream out
= socket.getOutputStream();
OutputStreamWriter osw
= new OutputStreamWriter(out,"UTF-8");
PrintWriter pw
= new PrintWriter(osw,true);
/*
* 创建一个Scanner用于获取用户输入的内容
*/
Scanner scanner = new Scanner(System.in);
String line = null;
System.out.println("请输入昵称:");
String nickName = scanner.nextLine();
//这里应该有对昵称的必要验证
//首先把昵称发送至服务端
pw.println(nickName);
//昵称输入完毕后，提示用户开始聊天
System.out.println(
"欢迎你:"+nickName+",开始聊天吧!");
while(true){
line = scanner.nextLine();
pw.println(line);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Client client = new Client();
client.start();
}
/**
* 该线程类用于循环读取来自服务端的消息，并
* 输出到控制台
* @author Administrator
*
*/
class GetMessageHandler implements Runnable{
public void run() {
/*
* 1：通过Socket获取输入流
* 2: 将输入流转换为缓冲字符输入流
* 3: 循环读取服务端发送的信息并
* 输出到控制台
*/
try {
InputStream in
= socket.getInputStream();
InputStreamReader isr
= new InputStreamReader(in,"UTF-8");
BufferedReader br
= new BufferedReader(isr);
while(true){
System.out.println(br.readLine());
}
} catch (Exception e) {
}
}
}
}

package day05.chat;
import java.io.FileInputStream;
import java.util.Properties;
public class Config {
static Properties properties = new Properties();
static{
FileInputStream fis;
try {
fis = new FileInputStream(
"clientconfig.properties");
properties.load(fis);
} catch (Exception e) {
e.printStackTrace();
}
}
public static String getKeyToString(String key){
return properties.getProperty(key);
}
public static int getKeyToInt(String key){
return Integer.parseInt(properties.getProperty(key));
}
public double getKeyToDouble(String key){
return Double.parseDouble(properties.getProperty(key));
}
public static void main(String[] args) {
System.out.println(Config.getKeyToString("server_host"));
}
}

http://mirrors.cnnic.cn/apache//xerces/j/source/Xerces-J-src.2.11.0.zip 回去要用的包

好久不见

讨厌计信系

暂时没时间加注释
package jdom;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.Namespace;
import org.jdom.output.XMLOutputter;
public class Tomorrow {
Element root;
Document doc;
public Tomorrow(){
root=new Element("epp");
root.setAttribute("ns", "qinyongdi.com");
root.addContent(new Element("command"));
doc=new Document(root);
createRegister(root);
createContact(root);
createBilling(root);
XMLOutputter xml=new XMLOutputter();
try{
StringWriter writer=new StringWriter();
xml.output(doc,writer);
String str=writer.toString();
System.out.println(writer);
}catch(Exception e){
e.printStackTrace();
}
}
public Element label(String prefix,String tag){
Namespace ns = Namespace.getNamespace(prefix,
"uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882");
Element ele=new Element(tag,ns);
ele.addNamespaceDeclaration(ns);
return ele;
}
public void createRegister(Element root){
Element register=label("domain","registant");
List<String> list=createList();
for(int i=0;i<list.size();i++){
Element element=new Element(list.get(i));
element.setText(i+"");
register.addContent(element);
}
root.addContent(register);
}
public void createContact(Element root){
Element contact=label("domain","contact");
List<String> list=createList();
for(int i=0;i<list.size();i++){
Element element=new Element(list.get(i));
element.setText(i+"");
contact.addContent(element);
}
root.addContent(contact);
}
public void createBilling(Element root){
Element billing=label("domain","registant");
List<String> list=createList();
for(int i=0;i<list.size();i++){
Element element=new Element(list.get(i));
element.setText(i+"");
billing.addContent(element);
}
root.addContent(billing);
}
public List<String> createList(){
List<String> list=new ArrayList<String>();
return list;
}
public static void main(String[] args) {
Tomorrow t=new Tomorrow();
System.out.println("书写完毕");
}
}