Java开发实例大全提高篇——网络技术篇

最新推荐文章于 2023-07-02 18:03:38 发布

GavinMoreYoung

最新推荐文章于 2023-07-02 18:03:38 发布

阅读量101

点赞数

本文链接：https://blog.csdn.net/u013452217/article/details/122063944

版权

第5篇网络技术篇
第17章网络应用基础
17.1 网络地址解析
实例491 获取本地主机的IP地址
private JTextField tf_ip;
/**
* Launch the application
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
GetLocalHostIpFrame frame = new GetLocalHostIpFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public GetLocalHostIpFrame() {
super();
getContentPane().setLayout(null);
setTitle("获取本地主机的Ip地址");
setBounds(100, 100, 340, 211);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
InetAddress inetAddr = InetAddress.getLocalHost();// 创建本地主机的InetAddress对象
String ip = inetAddr.getHostAddress();// 获得本地主机的IP地址
tf_ip.setText(ip);// 在文本框中显示IP地址
} catch (UnknownHostException e1) {
e1.printStackTrace();
}
}
});
button.setText("获取IP地址");
button.setBounds(29, 113, 106, 28);
getContentPane().add(button);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 16));
label.setText("获取本地主机的Ip地址");
label.setBounds(73, 22, 171, 35);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("Ip地址：");
label_1.setBounds(29, 75, 66, 18);
getContentPane().add(label_1);

tf_ip = new JTextField();
tf_ip.setBounds(88, 73, 199, 22);
getContentPane().add(tf_ip);

实例492 获取本地主机的域名和主机名
private JTextField tf_canonical;
private JTextField tf_host;
/**
* Launch the application
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
GetLocalHostNameFrame frame = new GetLocalHostNameFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public GetLocalHostNameFrame() {
super();
getContentPane().setLayout(null);
setTitle("获取本地主机的域名和主机名");
setBounds(100, 100, 333, 226);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
InetAddress inetAddr = InetAddress.getLocalHost();// 创建本地主机的InetAddress对象
String canonical = inetAddr.getCanonicalHostName();// 获取本地主机的域名
String host = inetAddr.getHostName();// 获取本地主机的主机名
tf_canonical.setText(canonical);// 在文本框中显示本地主机的域名
tf_host.setText(host);// 在文本框中显示本地主机的主机名
} catch (UnknownHostException e1) {
e1.printStackTrace();
}
}
});
button.setText("获取域名和主机名");
button.setBounds(28, 150, 150, 28);
getContentPane().add(button);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 16));
label.setText("获取本地主机的域名和主机名");
label.setBounds(46, 21, 223, 35);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("主机名：");
label_1.setBounds(28, 112, 66, 18);
getContentPane().add(label_1);

tf_host = new JTextField();
tf_host.setBounds(87, 110, 199, 22);
getContentPane().add(tf_host);

final JLabel label_2 = new JLabel();
label_2.setText("域名：");
label_2.setBounds(28, 72, 66, 18);
getContentPane().add(label_2);

tf_canonical = new JTextField();
tf_canonical.setBounds(87, 70, 199, 22);
getContentPane().add(tf_canonical);
//
}

实例493 通过域名获得IP地址
private JTextField tf_domain;
private JTextField tf_ip;
/**
* Launch the application
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ByDomainGainIpFrame frame = new ByDomainGainIpFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public ByDomainGainIpFrame() {
super();
getContentPane().setLayout(null);
setTitle("通过域名获得IP地址");
setBounds(100, 100, 340, 211);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
String domain = tf_domain.getText();// 获得输入的域名
InetAddress inetAddr = InetAddress.getByName(domain);// 创建InetAddress对象
String ip = inetAddr.getHostAddress();// 获得IP地址
tf_ip.setText(ip);// 在文本框中显示IP地址
} catch (UnknownHostException e1) {
e1.printStackTrace();
}
}
});
button.setText("获取IP地址");
button.setBounds(29, 135, 106, 28);
getContentPane().add(button);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 16));
label.setText("通过域名获得IP地址");
label.setBounds(89, 22, 171, 35);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("IP地址：");
label_1.setBounds(29, 98, 66, 18);
getContentPane().add(label_1);

tf_ip = new JTextField();
tf_ip.setBounds(98, 96, 189, 22);
getContentPane().add(tf_ip);

final JLabel label_2 = new JLabel();
label_2.setText("输入域名：");
label_2.setBounds(29, 63, 66, 18);
getContentPane().add(label_2);

tf_domain = new JTextField();
tf_domain.setBounds(99, 63, 188, 22);
getContentPane().add(tf_domain);
//
}

实例494 通过IP地址获得域名和主机名
private JTextField tf_ip;
private JTextField tf_canonical;
private JTextField tf_host;

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ByIpGainDomainFrame frame = new ByIpGainDomainFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public ByIpGainDomainFrame() {
super();
getContentPane().setLayout(null);
setTitle("通过IP地址获得域名和主机名");
setBounds(100, 100, 333, 218);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
String ip = tf_ip.getText();// IP地址
String[] ipStr = ip.split("[.]");// IP转换为字符串数组
byte[] ipBytes = new byte[4];// 声明存储转换后IP的字节数组
for (int i = 0; i < 4; i++) {
int m = Integer.parseInt(ipStr[i]);// 转换为整数
byte b = (byte) (m & 0xff);// 转换为字节
ipBytes[i] = b;// 赋值给字节数组
}
InetAddress inetAddr = InetAddress.getByAddress(ipBytes);// 创建InetAddress对象
String canonical = inetAddr.getCanonicalHostName();// 获取域名
String host = inetAddr.getHostName();// 获取主机名
tf_canonical.setText(canonical);// 在文本框中显示域名
tf_host.setText(host);// 在文本框中显示主机名
} catch (UnknownHostException e1) {
e1.printStackTrace();
}
}
});
button.setText("获取域名和主机名");
button.setBounds(28, 136, 150, 28);
getContentPane().add(button);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 16));
label.setText("通过IP地址获得域名和主机名");
label.setBounds(51, 10, 223, 35);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("主机名：");
label_1.setBounds(28, 110, 66, 18);
getContentPane().add(label_1);

tf_host = new JTextField();
tf_host.setBounds(87, 108, 199, 22);
getContentPane().add(tf_host);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
System.exit(0);
}
});
button_1.setText("退出系统");
button_1.setBounds(191, 136, 95, 28);
getContentPane().add(button_1);

final JLabel label_2 = new JLabel();
label_2.setText("域名：");
label_2.setBounds(28, 82, 66, 18);
getContentPane().add(label_2);

tf_canonical = new JTextField();
tf_canonical.setBounds(87, 80, 199, 22);
getContentPane().add(tf_canonical);

final JLabel label_3 = new JLabel();
label_3.setText("输入IP地址：");
label_3.setBounds(10, 51, 84, 18);
getContentPane().add(label_3);

tf_ip = new JTextField();
tf_ip.setBounds(87, 52, 199, 22);
getContentPane().add(tf_ip);
//
}

实例495 获得内网的所有IP地址
private JTextArea ta_allIp;
static public Hashtable<String, String> pingMap; // 用于存储所ping的IP是否为内网IP的集合

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
GainAllIpFrame frame = new GainAllIpFrame();
frame.setVisible(true);
}

public void gainAllIp() throws Exception {// 获得所有IP，并显示在文本域中的方法
InetAddress host = InetAddress.getLocalHost();// 获得本机的InetAddress对象
String hostAddress = host.getHostAddress();// 获得本机的IP地址
int pos = hostAddress.lastIndexOf(".");// 获得IP地址中最后一个点的位置
String wd = hostAddress.substring(0, pos + 1);// 对本机的IP进行截取，获得网段
for (int i = 1; i <= 255; i++) { // 对局域网的IP地址进行遍历
String ip = wd + i;// 生成IP地址
PingIpThread thread = new PingIpThread(ip);// 创建线程对象
thread.start();// 启动线程对象
}
Set<String> set = pingMap.keySet();// 获得集合中键的Set视图
Iterator<String> it = set.iterator();// 获得迭代器对象
while (it.hasNext()) { // 迭代器中有元素，则执行循环体
String key = it.next(); // 获得下一个键的名称
String value = pingMap.get(key);// 获得指定键的值
if (value.equals("true")) {
ta_allIp.append(key + "\n");// 追加显示IP地址
}
}
}

/**
* Create the frame
*/
public GainAllIpFrame() {
super();
addWindowListener(new WindowAdapter() {
public void windowOpened(final WindowEvent e) {
try {
gainAllIp();
ta_allIp.setText(null);
} catch (Exception e1) {
ta_allIp.setText(null);
}
}
});
setTitle("获得内网的所有IP地址");
setBounds(400, 200, 270, 375);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_allIp = new JTextArea();
scrollPane.setViewportView(ta_allIp);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JButton button_2 = new JButton();
button_2.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
ta_allIp.setText(null);
gainAllIp();
} catch (Exception e1) {
ta_allIp.setText(null);
JOptionPane.showMessageDialog(null, "应用程序异常，请再试一次。");
}
}
});
button_2.setText("显示所有IP");
panel.add(button_2);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
System.exit(0);
}
});
button.setText("退出");
panel.add(button);

final JButton button_1 = new JButton();
button_1.setText("New JButton");
panel.add(button_1);
pingMap = new Hashtable<String, String>();
}

class PingIpThread extends Thread {// 判断给定IP是否为内网IP的线程对象
public String ip; // 表示IP地址的成员变量
public PingIpThread(String ip) {// 参数为需要判断的IP地址
this.ip = ip;
}
public void run() {
try {
// 获得所ping的IP进程，-w 280是等待每次回复的超时时间，-n 1是要发送的回显请求数
Process process = Runtime.getRuntime().exec(
"ping " + ip + " -w 280 -n 1");
InputStream is = process.getInputStream();// 获得进程的输入流对象
InputStreamReader isr = new InputStreamReader(is);// 创建InputStreamReader对象
BufferedReader in = new BufferedReader(isr);// 创建缓冲字符流对象
String line = in.readLine();// 读取信息
while (line != null) {
if (line != null && !line.equals("")) {
if (line.substring(0, 2).equals("来自")
|| (line.length() > 10 && line.substring(0, 10)
.equals("Reply from"))) {// 判断是ping通过的IP地址
pingMap.put(ip, "true");// 向集合中添加IP
}
}
line = in.readLine();// 再读取信息
}
} catch (IOException e) {
}
}
}

17.2 网络资源管理
实例496 获取网络资源的大小
private JTextField tf_size;
private JTextField tf_address;
/**
* Launch the application
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
InternetSizeFrame frame = new InternetSizeFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public InternetSizeFrame() {
super();
setTitle("获取网络资源的大小");
getContentPane().setLayout(null);
setBounds(100, 100, 391, 223);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();
label.setText("输入网址：");
label.setBounds(10, 77, 79, 18);
getContentPane().add(label);

tf_address = new JTextField();
tf_address.setBounds(82, 75, 286, 22);
getContentPane().add(tf_address);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
String address = tf_address.getText().trim();// 获得输入的网址
try{
long len = netSourceSize(address);// 调用方法获取网络资源的大小
tf_size.setText(String.valueOf(len)+" 字节");// 在文本框中显示网络资源的大小
}catch(Exception ex){
ex.printStackTrace();
}
}
});
button.setText("获得大小");
button.setBounds(282, 123, 86, 28);
getContentPane().add(button);

final JLabel label_1 = new JLabel();
label_1.setText("网络资源的大小为：");
label_1.setBounds(10, 128, 127, 18);
getContentPane().add(label_1);

tf_size = new JTextField();
tf_size.setBounds(131, 126, 145, 22);
getContentPane().add(tf_size);

final JLabel label_2 = new JLabel();
label_2.setForeground(new Color(0, 0, 255));
label_2.setFont(new Font("", Font.BOLD, 22));
label_2.setText("获取网络资源的大小");
label_2.setBounds(82, 8, 239, 44);
getContentPane().add(label_2);
}
public long netSourceSize(String sUrl) throws Exception{
URL url = new URL(sUrl); // 创建URL对象
URLConnection urlConn = url.openConnection();          // 获得网络连接对象
urlConn.connect();                                     // 打开到url引用资源的通信链接
return urlConn.getContentLength();                     // 以字节为单位返回资源的大小
}

实例497 解析网页中的内容
private JTextArea ta_content;
private JTextField tf_address;
/**
* Launch the application
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
InternetContentFrame frame = new InternetContentFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public InternetContentFrame() {
super();
setTitle("解析网页中的内容");
setBounds(100, 100, 484, 375);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("输入网址：");
panel.add(label);

tf_address = new JTextField();
tf_address.setPreferredSize(new Dimension(260,25));
panel.add(tf_address);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
String address = tf_address.getText().trim();// 获得输入的网址
Collection urlCollection = getURLCollection(address);// 调用方法，获得网页内容的集合对象
Iterator it = urlCollection.iterator(); // 获得集合的迭代器对象
while(it.hasNext()){
ta_content.append((String)it.next()+"\n"); // 在文本域中显示解析的内容
}
}
});
button.setText("解析网页");
panel.add(button);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_content = new JTextArea();
ta_content.setFont(new Font("", Font.BOLD, 14));
scrollPane.setViewportView(ta_content);
//
}
public Collection<String> getURLCollection(String urlString){
URL url = null;                             // 声明URL
URLConnection conn = null;                  // 声明URLConnection
Collection<String> urlCollection = new ArrayList<String>(); // 创建集合对象
try{
url = new URL(urlString);               // 创建URL对象
conn = url.openConnection();            // 获得连接对象
conn.connect();                         // 打开到url引用资源的通信链接
InputStream is = conn.getInputStream(); // 获取流对象
InputStreamReader in = new InputStreamReader(is,"UTF-8"); // 转换为字符流
BufferedReader br = new BufferedReader(in); // 创建缓冲流对象
String nextLine = br.readLine();            // 读取信息，解析网页
while (nextLine !=null){
urlCollection.add(nextLine);   // 解析网页的全部内容，添加到集合中
nextLine = br.readLine();      // 读取信息，解析网页
}
}catch(Exception ex){
ex.printStackTrace();
}
return urlCollection;
}

实例498 网络资源的单线程下载
private JTextField tf_address;
/**
* Launch the application
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
SingleThreadDownloadFrame frame = new SingleThreadDownloadFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public SingleThreadDownloadFrame() {
super();
getContentPane().setLayout(null);
setTitle("网络资源的单线程下载");
setBounds(100, 100, 500, 237);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();
label.setText("网络资源的网址：");
label.setBounds(10, 88, 118, 18);
getContentPane().add(label);

tf_address = new JTextField();
tf_address.setBounds(117, 86, 357, 22);
getContentPane().add(tf_address);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
String address = tf_address.getText().trim();// 获得网址
download(address); // 下载文件
}
});
button.setText("单击开始下载");
button.setBounds(41, 144, 145, 28);
getContentPane().add(button);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
tf_address.setText(null);// 清除文本框内容
tf_address.requestFocus();// 文本框获得焦点
}
});
button_1.setText("清空");
button_1.setBounds(204, 144, 106, 28);
getContentPane().add(button_1);

final JButton button_2 = new JButton();
button_2.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
System.exit(0);
}
});
button_2.setText("退出");
button_2.setBounds(328, 144, 106, 28);
getContentPane().add(button_2);

final JLabel label_1 = new JLabel();
label_1.setForeground(new Color(0, 0, 255));
label_1.setFont(new Font("", Font.BOLD, 24));
label_1.setText("网络资源的单线程下载");
label_1.setBounds(117, 21, 301, 48);
getContentPane().add(label_1);
}
public void download(String urlAddr){         // 从指定网址下载文件
try {
URL url = new URL(urlAddr);    // 创建URL对象
URLConnection urlConn = url.openConnection(); // 获得连接对象
urlConn.connect();                           // 打开到url引用资源的通信链接
InputStream in = urlConn.getInputStream() ;      // 获得输入流对象
String filePath = url.getFile();                  // 获得完整路径
int pos = filePath.lastIndexOf("/");              // 获得路径中最后一个斜杠的位置
String fileName = filePath.substring(pos+1);      // 截取文件名
FileOutputStream out = new FileOutputStream("C:/"+fileName); // 创建输出流对象
byte[] bytes = new byte[1024];                 // 声明存放下载内容的字节数组
int len = in.read(bytes);                       // 从输入流中读取内容
while (len != -1){
out.write(bytes,0,len);                     // 将读取的内容写到输出流
len = in.read(bytes);                      // 继续从输入流中读取内容
}
out.close();          // 关闭输出流
in.close();           // 关闭输入流
JOptionPane.showMessageDialog(null, "下载完毕");
} catch (Exception e) {
e.printStackTrace();
}
}

实例499 网络资源的多线程下载
DownMultiThread.java
private String sUrl = "";// 网络资源地址
private File desFile;// 需要写入的目标文件对象
private long startPos;// 写入的开始位置
private long endPos;// 写入的结束位置
/**
* @param sUrl 网络资源地址
* @param file 需要写入的目标文件对象
* @param startPos 写入的开始位置
* @param endPos 写入的结束位置
*/
public DownMultiThread(String sUrl,File desFile,long startPos,long endPos) {
this.sUrl = sUrl;
this.desFile = desFile;
this.startPos = startPos;
this.endPos = endPos;
}
@Override
public void run() {
try {
URL url = new URL(sUrl);// 创建下载资源的URL对象
HttpURLConnection conn = (HttpURLConnection)url.openConnection();// 打开连接对象
conn.setRequestProperty("User-Agent", "NetFox");// 设置请求属性
String rangeProperty = "bytes="+startPos+"-";// 定义范围属性
if (endPos > 0){
rangeProperty = "bytes="+startPos+"-" + endPos;// 调整范围属性的值
}
conn.setRequestProperty("RANGE", rangeProperty);// 指定范围属性
RandomAccessFile out = new RandomAccessFile(desFile, "rw");// 创建可读写的流对象
out.seek(startPos);// 指定读写的开始标记
InputStream in = conn.getInputStream();// 获得网络资源的输入流对象
BufferedInputStream bin = new BufferedInputStream(in);// 创建输入缓冲流对象
byte[] buff = new byte[2048];// 创建字节数组
int len = -1;// 声明存放读取字节数的变量
len=bin.read(buff);// 读取到内容并添加到字节数组
while (len!=-1){
out.write(buff,0,len);// 写入磁盘文件
len=bin.read(buff);// 读取到内容并添加到字节数组
}
out.close();// 关闭流
bin.close();// 关闭流
conn.disconnect();// 断开连接
}catch(Exception ex) {
JOptionPane.showMessageDialog(null, ex.getMessage());
}
}
MultiThreadDownFrame.java
private JTextField tf_address;

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
MultiThreadDownFrame frame = new MultiThreadDownFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

public MultiThreadDownFrame() {
super();
getContentPane().setLayout(null);
setTitle("网络资源的多线程下载");
setBounds(100, 100, 482, 189);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JButton button = new JButton();
button.setBounds(10, 95, 106, 28);
getContentPane().add(button);
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
String address = tf_address.getText();// 获得网络资源地址
download(address, "c:\\01.flv", 2);// 调用download()方法,将下载的网络资源保存到磁盘
} catch (Exception e1) {
e1.printStackTrace();
}
}
});
button.setText("下    载");

final JLabel label = new JLabel();
label.setText("网络资源的地址：");
label.setBounds(10, 44, 106, 18);
getContentPane().add(label);

tf_address = new JTextField();
tf_address.setBounds(114, 42, 341, 22);
getContentPane().add(tf_address);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
tf_address.setText(null);
}
});
button_1.setText("清    空");
button_1.setBounds(179, 95, 106, 28);
getContentPane().add(button_1);

final JButton button_2 = new JButton();
button_2.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
System.exit(0);
}
});
button_2.setText("退    出");
button_2.setBounds(349, 95, 106, 28);
getContentPane().add(button_2);
}

public void download(String url, String dest, int threadNum)
throws Exception {
URL downURL = new URL(url);// 创建网络资源的URL
HttpURLConnection conn = (HttpURLConnection) downURL.openConnection();// 打开网络边接
long fileLength = -1;// 用于存储文件长度的变量
int stateFlagCode = conn.getResponseCode();// 获得连接状态标记代码
if (stateFlagCode == 200) {// 网络连接正常
fileLength = conn.getContentLength();// 获得文件的长度
conn.disconnect();// 取消网络连接
}
if (fileLength > 0) {
long byteCounts = fileLength / threadNum + 1;// 计算每个线程的字节数
File file = new File(dest);// 创建目标文件的File对象
int i = 0;
while (i < threadNum) {
long startPosition = byteCounts * i;// 定义开始位置
long endPosition = byteCounts * (i + 1);// 定义结束位置
if (i == threadNum - 1) {
DownMultiThread fileThread = new DownMultiThread(url, file,
startPosition, 0);// 创建DownMultiThread线程的实例
new Thread(fileThread).start();// 启动线程对象
} else {
DownMultiThread fileThread = new DownMultiThread(url, file,
startPosition, endPosition);// 创建DownMultiThread线程的实例
new Thread(fileThread).start();// 启动线程对象
}
i++;
}
JOptionPane.showMessageDialog(null, "完成网络资源的下载。");
}
}

实例500 下载网络资源的断点续传
private JTextField tf_totalLength;
private JTextField tf_residuaryLength;
private JTextField tf_readToPos;
private JTextField tf_address;
private JTextField tf_endPos;
private JTextField tf_startPos;
private String urlAddress = "";// 用于存储网络资源的地址
private long totalLength = 0;// 存储网络资源的大小，以字节为单位
private long readToPos = 0;// 存储上次读取到的位置
private long residuaryLength = 0;// 存储未读内容的大小

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
BreakPointSuperveneFrame frame = new BreakPointSuperveneFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public BreakPointSuperveneFrame() {
super();
getContentPane().setLayout(null);
setTitle("下载网络资源的断点续传");
setBounds(100, 100, 514, 238);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

tf_startPos = new JTextField();
tf_startPos.setBounds(80, 165, 113, 22);
getContentPane().add(tf_startPos);

final JLabel label = new JLabel();
label.setText("起始位置：");
label.setBounds(10, 167, 74, 18);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("结束位置：");
label_1.setBounds(199, 167, 74, 18);
getContentPane().add(label_1);

tf_endPos = new JTextField();
tf_endPos.setBounds(267, 165, 117, 22);
getContentPane().add(tf_endPos);

final JLabel label_2 = new JLabel();
label_2.setText("网络资源的地址：");
label_2.setBounds(10, 52, 113, 18);
getContentPane().add(label_2);

tf_address = new JTextField();
tf_address.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
urlAddress = tf_address.getText().trim();
URL url = new URL(urlAddress);// 获得网络资源的URL
HttpURLConnection connection = (HttpURLConnection) url
.openConnection();// 获得连接对象
connection.connect();// 连接网络资源
totalLength = connection.getContentLength();// 获得网络资源的长度
connection.disconnect();// 断开连接
tf_totalLength.setText(String.valueOf(totalLength));// 显示总长度
tf_readToPos.setText("0");// 显示上次读取到的位置
residuaryLength = totalLength;// 未读内容为文件总长度
tf_residuaryLength.setText(String.valueOf(residuaryLength));// 显示未读内容
} catch (MalformedURLException e1) {
e1.printStackTrace();
} catch (IOException e2) {
e2.printStackTrace();
}

}
});
tf_address.setBounds(119, 50, 365, 22);
getContentPane().add(tf_address);

final JLabel label_3 = new JLabel();
label_3.setForeground(new Color(0, 0, 255));
label_3.setFont(new Font("", Font.BOLD, 14));
label_3.setText("输入网络资源的地址并回车，可以获得网络资源的大小。");
label_3.setBounds(10, 10, 384, 22);
getContentPane().add(label_3);

final JLabel label_4 = new JLabel();
label_4.setForeground(new Color(128, 0, 0));
label_4.setText("网络资源的大小为");
label_4.setBounds(10, 76, 113, 38);
getContentPane().add(label_4);

final JLabel label_5 = new JLabel();
label_5.setText("上次读取到");
label_5.setBounds(10, 123, 74, 18);
getContentPane().add(label_5);

tf_readToPos = new JTextField();
tf_readToPos.setBounds(80, 121, 113, 22);
tf_readToPos.setEnabled(false);
getContentPane().add(tf_readToPos);

final JLabel label_6 = new JLabel();
label_6.setText("字节处，还剩");
label_6.setBounds(202, 123, 87, 18);
getContentPane().add(label_6);

tf_residuaryLength = new JTextField();
tf_residuaryLength.setBounds(285, 120, 117, 22);
tf_residuaryLength.setEnabled(false);
getContentPane().add(tf_residuaryLength);

final JLabel label_7 = new JLabel();
label_7.setText("字节未读。");
label_7.setBounds(404, 123, 80, 18);
getContentPane().add(label_7);

final JLabel label_4_1 = new JLabel();
label_4_1.setForeground(new Color(128, 0, 0));
label_4_1.setText("个字节。");
label_4_1.setBounds(404, 76, 80, 38);
getContentPane().add(label_4_1);

tf_totalLength = new JTextField();
tf_totalLength.setBounds(119, 84, 283, 22);
tf_totalLength.setEnabled(false);
getContentPane().add(tf_totalLength);

final JButton button = new JButton();
button.setBounds(395, 162, 89, 28);
getContentPane().add(button);
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
if (totalLength == 0) {
JOptionPane.showMessageDialog(null,
"没有网络资源。\n\n请输入正确的网址，然后回车。");
return;
}
long startPos = 0;// 起始位置
long endPos = 0;// 结束位置
try {
startPos = Long.parseLong(tf_startPos.getText().trim());// 起始位置
endPos = Long.parseLong(tf_endPos.getText().trim());// 结束位置
} catch (Exception ex) {
JOptionPane.showMessageDialog(null, "输入的起始位置或结束位置不正确。");
return;
}
readToPos = endPos;// 记录读取到的位置
residuaryLength = totalLength - readToPos;// 记录未读内容的大小
tf_readToPos.setText(String.valueOf(readToPos));// 显示读取到的位置
tf_residuaryLength.setText(String.valueOf(residuaryLength));// 显示未读字节数
tf_startPos.setText(String.valueOf(readToPos));// 设置下一个读取点的开始位置
tf_endPos.setText(String.valueOf(totalLength));// 设置下一个读取点的结束位置
tf_endPos.requestFocus();// 使结束位置文本框获得焦点
tf_endPos.selectAll();// 选择结束位置文本框中的全部内容，方便输入结束位置值
download(startPos, endPos);// 调用方法进行下载
}
});
button.setText("开始下载");
}

public void download(long startPosition, long endPosition) {
try {
URL url = new URL(urlAddress);// 获得网络资源的URL
HttpURLConnection connection = (HttpURLConnection) url
.openConnection();// 获得连接对象
connection.setRequestProperty("User-Agent", "NetFox");// 设置请求属性
String rangeProperty = "bytes=" + startPosition + "-";// 定义请求范围属性
if (endPosition > 0) {
rangeProperty += endPosition;// 调整请求范围属性
}
connection.setRequestProperty("RANGE", rangeProperty);// 设置请求范围属性
connection.connect();// 连接网络资源
InputStream in = connection.getInputStream();// 获得输入流对象
String file = url.getFile();// 获得文件对象
String name = file.substring(file.lastIndexOf('/') + 1);// 获得文件名
FileOutputStream out = new FileOutputStream("c:/" + name, true);// 创建输出流对象,保存下载的资源
byte[] buff = new byte[2048];// 创建字节数组
int len = 0;// 定义存储读取内容长度的变量
len = in.read(buff);// 读取内容
while (len != -1) {
out.write(buff, 0, len);// 写入磁盘
len = in.read(buff);// 读取内容
}
out.close();// 关闭流
in.close();// 关闭流
connection.disconnect();// 断开连接
if (readToPos > 0 && readToPos == totalLength) {
JOptionPane.showMessageDialog(null, "完成网络资源的下载。\n单击“确定”按钮退出程序。");
System.exit(0);
}
} catch (Exception e) {
e.printStackTrace();
}
}

第18章 TCP套接字
18.1 Socket基础
实例501 建立服务器套接字
private JTextArea ta_info;
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public void getServer() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
ta_info.append("连接成功......\n");
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getServer(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("建立服务器套接字");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 260, 167);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}

实例502 建立客户端套接字
private Socket socket; // 声明Socket对象
private JTextArea ta_info = new JTextArea(); // 创建JtextArea对象

public ClientSocketFrame() { // 构造方法
super(); // 调用父类的构造方法
setTitle("建立客户端套接字");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 254, 166);
final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);
scrollPane.setViewportView(ta_info);
}

private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("127.0.0.1", 1978); // 实例化Socket对象
ta_info.append("完成连接。\n"); // 文本域中提示信息
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

实例503 设置等待连接的超时时间
private JTextArea ta_info;
private ServerSocket server; // 声明ServerSocket对象
public void getserver() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
server.setSoTimeout(10000);// 设置连接超时时间为10秒
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
server.accept();// 等待客户机连接
}
} catch (SocketTimeoutException e) {
ta_info.append("连接超时......");
JOptionPane.showMessageDialog(null, "连接超时......");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) { // 主方法
ConnectionTimeoutSetFrame frame = new ConnectionTimeoutSetFrame(); // 创建本类对象
frame.setVisible(true);
frame.getserver(); // 调用方法
}
public ConnectionTimeoutSetFrame() {
super();
setTitle("设置等待连接的超时时间");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 336, 257);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}

实例504 获取Socket信息
ServerSocketFrame.java
private JTextArea ta_info;
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public void getserver() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
ta_info.append("连接成功......\n");
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getserver(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 336, 257);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}

ClientSocketFrame.java
private Socket socket; // 声明Socket对象
private JTextArea ta = new JTextArea(); // 创建JtextArea对象

public ClientSocketFrame() { // 构造方法
super(); // 调用父类的构造方法
setTitle("获取Socket信息");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 351, 257);
final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);
scrollPane.setViewportView(ta);
}

private void connect() { // 连接套接字方法
ta.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
ta.append("完成连接。\n"); // 文本域中提示信息
InetAddress netAddress = socket.getInetAddress();// 获得远程服务器的地址
String netIp = netAddress.getHostAddress();// 获得远程服务器的IP地址
int netPort = socket.getPort();// 获得远程服务器的端口号
InetAddress localAddress = socket.getLocalAddress();// 获得客户端的地址
String localIp = localAddress.getHostAddress();// 获得客户端的IP地址
int localPort = socket.getLocalPort();// 获得客户端的端口号
ta.append("远程服务器的IP地址：" + netIp + "\n");
ta.append("远程服务器的端口号：" + netPort + "\n");
ta.append("客户机本地的IP地址：" + localIp + "\n");
ta.append("客户机本地的端口号：" + localPort + "\n");
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

实例505 接收和发送Socket信息
ClientSocketFrame.java
private PrintWriter writer; // 声明PrintWriter类对象
private Socket socket; // 声明Socket对象
private JTextArea ta_info = new JTextArea(); // 创建JtextArea对象
private JTextField tf_send = new JTextField(); // 创建JtextField对象
private Container cc; // 声明Container对象

public ClientSocketFrame() { // 构造方法
super(); // 调用父类的构造方法
setTitle("客户端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 351, 257);
cc = this.getContentPane(); // 实例化对象
cc.add(tf_send, "South"); // 将文本框放在窗体的下部
tf_send.addActionListener(new ActionListener() { // 绑定事件
public void actionPerformed(ActionEvent e) {
writer.println(tf_send.getText()); // 将文本框中信息写入流
ta_info.append("客户端发送的信息是：" + tf_send.getText() + "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(""); // 将文本框清空
}
});
final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);
scrollPane.setViewportView(ta_info);
}

private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
writer = new PrintWriter(socket.getOutputStream(), true);// 创建输出流对象
ta_info.append("完成连接。\n"); // 文本域中提示信息
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

ServerSocketFrame.java
private JTextArea ta_info;// 声明文本域,用于显示连接信息和接收到的信息
private BufferedReader reader; // 声明BufferedReader对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public void getServer() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
ta_info.append("连接成功。\n"); // 输出信息
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream())); // 实例化BufferedReader对象
getClientInfo(); // 调用getClientInfo()方法
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
while (true) { // 如果套接字是连接状态
ta_info.append("接收到客户机发送的信息：" + reader.readLine() + "\n"); // 获得客户端信息
}
} catch (Exception e) {
ta_info.append("客户端已退出。\n"); // 输出异常信息
} finally {
try {
if (reader != null) {
reader.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getServer(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 336, 257);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}

实例506 关闭Socket缓冲
private JTextArea ta_info;
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public ServerSocketFrame() {
super();
setTitle("关闭Socket缓冲");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 278, 185);
final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}

public void getserver() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
ta_info.append("如果连接成功就会关闭Socket缓冲......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
socket.setTcpNoDelay(true);// 关闭Socket缓冲，提高数据传输速度
ta_info.append("已经关闭Socket缓冲......\n"); // 输出信息
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getserver(); // 调用方法
}

18.2 TCP网络通信
实例507 使用Socket通信
ServerSocketFrame.java
private JTextField tf_send;
private JTextArea ta_info;
private PrintWriter writer; // 声明PrintWriter类对象
private BufferedReader reader; // 声明BufferedReader对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public void getserver() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream())); // 实例化BufferedReader对象
writer = new PrintWriter(socket.getOutputStream(), true);
getClientInfo(); // 调用getClientInfo()方法
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
while (true) { // 如果套接字是连接状态
String line = reader.readLine();
if (line != null)
ta_info.append("接收到客户机发送的信息：" + line + "\n"); // 获得客户端信息
}
} catch (Exception e) {
ta_info.append("客户端已退出。\n"); // 输出异常信息
} finally {
try {
if (reader != null) {
reader.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getserver(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 379, 260);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("服务器发送的信息：");
panel.add(label);

tf_send = new JTextField();
tf_send.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
writer.println(tf_send.getText()); // 将文本框中信息写入流
ta_info.append("服务器发送的信息是：" + tf_send.getText() + "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(""); // 将文本框清空
}
});
tf_send.setPreferredSize(new Dimension(220, 25));
panel.add(tf_send);
}
ClientSocketFrame.java
private JLabel label;
private JPanel panel;
private PrintWriter writer; // 声明PrintWriter类对象
private BufferedReader reader; // 声明BufferedReader对象
private Socket socket; // 声明Socket对象
private JTextArea ta_info = new JTextArea(); // 创建JtextArea对象
private JTextField tf_send = new JTextField(); // 创建JtextField对象

public ClientSocketFrame() { // 构造方法
super(); // 调用父类的构造方法
setTitle("客户端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 361, 257);
final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);
scrollPane.setViewportView(ta_info);
getContentPane().add(getPanel(), BorderLayout.NORTH);
}

private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
while (true) {
writer = new PrintWriter(socket.getOutputStream(), true);
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream())); // 实例化BufferedReader对象
ta_info.append("完成连接。\n"); // 文本域中提示信息
getClientInfo();
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

private void getClientInfo() {
try {
while (true) { // 如果套接字是连接状态
if (reader != null) {
String line = reader.readLine();
if (line != null)
ta_info.append("接收到服务器发送的信息：" + line + "\n"); // 获得客户端信息
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (reader != null) {

reader.close();// 关闭流

}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* @return
*/
protected JPanel getPanel() {
if (panel == null) {
panel = new JPanel();
panel.add(getLabel());
tf_send.setPreferredSize(new Dimension(200, 25));
panel.add(tf_send);
tf_send.addActionListener(new ActionListener() { // 绑定事件
public void actionPerformed(ActionEvent e) {
writer.println(tf_send.getText()); // 将文本框中信息写入流
ta_info.append("客户端发送的信息是：" + tf_send.getText()
+ "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(""); // 将文本框清空
}
});
}
return panel;
}

/**
* @return
*/
protected JLabel getLabel() {
if (label == null) {
label = new JLabel();
label.setText("客户端发送的信息：");
}
return label;
}

实例508 防止Socket传递汉字乱码
ServerSocketFrame.java
private JTextField tf_send;
private JTextArea ta_info;
private OutputStreamWriter out; // 创建流对象
private PrintWriter writer; // 声明PrintWriter类对象
private BufferedReader reader; // 声明BufferedReader对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public void getserver() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream(), "UTF-8")); // 实例化BufferedReader对象
out = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");
writer = new PrintWriter(out, true);
getClientInfo(); // 调用getClientInfo()方法
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
while (true) { // 如果套接字是连接状态
String line = reader.readLine();
if (line != null)
ta_info.append("接收到客户机发送的信息：" + line + "\n"); // 获得客户端信息
}
} catch (Exception e) {
ta_info.append("客户端已退出。\n"); // 输出异常信息
} finally {
try {
if (reader != null) {

reader.close();// 关闭流

}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getserver(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("防止传递汉字乱码服务器端");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 379, 260);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);

final JLabel label = new JLabel();
label.setText("服务器发送的信息：");
panel.add(label);

tf_send = new JTextField();
tf_send.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
writer.println(tf_send.getText()); // 将文本框中信息写入流
ta_info.append("服务器发送的信息是：" + tf_send.getText() + "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(" "); // 将文本框清空
}
});
tf_send.setPreferredSize(new Dimension(220, 25));
panel.add(tf_send);
}
ClientSocketFrame.java
private JLabel label;
private JPanel panel;
private OutputStreamWriter out; // 创建流对象
private PrintWriter writer; // 声明PrintWriter类对象
private BufferedReader reader; // 声明BufferedReader对象
private Socket socket; // 声明Socket对象
private JTextArea ta_info = new JTextArea(); // 创建JtextArea对象
private JTextField tf_send = new JTextField(); // 创建JtextField对象

public ClientSocketFrame() { // 构造方法
super(); // 调用父类的构造方法
setTitle("防止传递汉字乱码客户端");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 361, 257);
final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);
scrollPane.setViewportView(ta_info);
getContentPane().add(getPanel(), BorderLayout.SOUTH);
}

private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
while (true) {
out = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");
writer = new PrintWriter(out, true);
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream(), "UTF-8")); // 实例化BufferedReader对象
ta_info.append("完成连接。\n"); // 文本域中提示信息
getClientInfo();
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

private void getClientInfo() {
try {
while (true) { // 如果套接字是连接状态
if (reader != null) {
String line = reader.readLine();
if (line != null)
ta_info.append("接收到服务器发送的信息：" + line + "\n"); // 获得客户端信息
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (reader != null) {

reader.close();// 关闭流

}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* @return
*/
protected JPanel getPanel() {
if (panel == null) {
panel = new JPanel();
panel.add(getLabel());
tf_send.setPreferredSize(new Dimension(200, 25));
panel.add(tf_send);
tf_send.addActionListener(new ActionListener() { // 绑定事件
public void actionPerformed(ActionEvent e) {
writer.println(tf_send.getText()); // 将文本框中信息写入流
ta_info.append("客户端发送的信息是：" + tf_send.getText()
+ "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(" "); // 将文本框清空
}
});
}
return panel;
}

/**
* @return
*/
protected JLabel getLabel() {
if (label == null) {
label = new JLabel();
label.setText("客户端发送的信息：");
}
return label;
}

实例509 使用Socket传递对象
Student.java
private String id; // 类的成员变量
private String name;// 类的成员变量
public String getId() { // 成员变量的getter方法
return id;
}
public void setId(String id) {// 成员变量的setter方法
this.id = id;
}
public String getName() {// 成员变量的getter方法
return name;
}
public void setName(String name) {// 成员变量的setter方法
this.name = name;
}
ServerSocketFrame.java
private JTextField tf_name;
private JTextField tf_id;
private JTextArea ta_info;
private ObjectOutputStream out = null; // 创建流对象
private ObjectInputStream in = null; // 创建流对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public void getserver() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
ta_info.append("客户机连接成功\n"); // 输出信息
out = new ObjectOutputStream(socket.getOutputStream());
in = new ObjectInputStream(socket.getInputStream());
getClientInfo(); // 调用getClientInfo()方法
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
while (true) { // 如果套接字是连接状态
Student stud = (Student)in.readObject();
if (stud!=null)
ta_info.append("接收到客户机发送的编号为：" + stud.getId() + " 名称为：" +stud.getName() + "\n"); // 获得客户端信息
}
} catch (Exception e) {
ta_info.append("客户端已退出。\n"); // 输出异常信息
} finally {
try {
if (in != null) {
in.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getserver(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 379, 260);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("编号：");
panel.add(label);

tf_id = new JTextField();
tf_id.setPreferredSize(new Dimension(70,25));
panel.add(tf_id);

final JLabel label_1 = new JLabel();
label_1.setText("名称：");
panel.add(label_1);

tf_name = new JTextField();
tf_name.setPreferredSize(new Dimension(100,25));
panel.add(tf_name);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
Student stud = new Student();
stud.setId(tf_id.getText());
stud.setName(tf_name.getText());
try {
out.writeObject(stud);
} catch (IOException e1) {
e1.printStackTrace();
}
ta_info.append("服务器发送的编号是：" + tf_id.getText() + " 名称是："+tf_name.getText()+"\n"); // 将文本框中信息显示在文本域中
tf_id.setText(null); // 将文本框清空
tf_name.setText(null);
}
});
button.setText("发送");
panel.add(button);
}
ClientSocketFrame.java
private JButton button;
private JTextField tf_name;
private JLabel label_1;
private JLabel label;
private JPanel panel;
private ObjectInputStream in = null;// 创建流对象
private ObjectOutputStream out = null;// 创建流对象
private Socket socket;// 声明Socket对象
private JTextArea ta_info = new JTextArea();// 创建JtextArea对象
private JTextField tf_id = new JTextField();// 创建JtextField对象
private Container cc;// 声明Container对象

public ClientSocketFrame() { // 构造方法
super(); // 调用父类的构造方法
setTitle("客户端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 373, 257);
cc = this.getContentPane(); // 实例化对象
final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);
scrollPane.setViewportView(ta_info);
getContentPane().add(getPanel(), BorderLayout.NORTH);
}

private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
while (true){
out = new ObjectOutputStream(socket.getOutputStream());
in = new ObjectInputStream(socket.getInputStream());
ta_info.append("完成连接。\n"); // 文本域中提示信息
getClientInfo();
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}
private void getClientInfo() {
try {
while (true) { // 如果套接字是连接状态
Student stud = (Student)in.readObject();
if (stud!=null)
ta_info.append("接收到服务器发送的编号为：" + stud.getId() + " 名称为：" +stud.getName() + "\n"); // 获得服务器信息
}
} catch (Exception e) {
e.printStackTrace();
}
finally {
try {
if (in != null) {
in.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* @return
*/
protected JPanel getPanel() {
if (panel == null) {
panel = new JPanel();
panel.add(getLabel());
tf_id.setPreferredSize(new Dimension(70, 25));
panel.add(tf_id);
panel.add(getLabel_1());
panel.add(getTf_name());
panel.add(getButton());
}
return panel;
}

/**
* @return
*/
protected JLabel getLabel() {
if (label == null) {
label = new JLabel();
label.setText("编号：");
}
return label;
}
/**
* @return
*/
protected JLabel getLabel_1() {
if (label_1 == null) {
label_1 = new JLabel();
label_1.setText("名称：");
}
return label_1;
}
/**
* @return
*/
protected JTextField getTf_name() {
if (tf_name == null) {
tf_name = new JTextField();
tf_name.setPreferredSize(new Dimension(100, 25));
}
return tf_name;
}
/**
* @return
*/
protected JButton getButton() {
if (button == null) {
button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
Student stud = new Student();
stud.setId(tf_id.getText());
stud.setName(tf_name.getText());
try {
out.writeObject(stud);
} catch (IOException e1) {
e1.printStackTrace();
}
ta_info.append("客户端发送的编号是：" + tf_id.getText() + " 名称是："+tf_name.getText()+"\n"); // 将文本框中信息显示在文本域中
tf_id.setText(null); // 将文本框清空
tf_name.setText(null);
}
});
button.setText("发送");
}
return button;
}

实例510 使用Socket传输图片
ServerSocketFrame.java
private Image sendImg = null; // 声明图像对象
private Image receiveImg = null; // 声明图像对象
private SendImagePanel sendImagePanel = null; // 声明图像面板对象
private ReceiveImagePanel receiveImagePanel = null; // 声明图像面板对象
private File imgFile = null;// 声明所选择图片的File对象
private JTextField tf_path;
private DataOutputStream out = null; // 创建流对象
private DataInputStream in = null; // 创建流对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket
private long lengths = -1; // 图片文件的大小
public void getServer() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
while (true) { // 如果套接字是连接状态
socket = server.accept(); // 实例化Socket对象
out = new DataOutputStream(socket.getOutputStream());// 获得输出流对象
in = new DataInputStream(socket.getInputStream());// 获得输入流对象
getClientInfo(); // 调用getClientInfo()方法
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
long lengths = in.readLong();// 读取图片文件的长度
byte[] bt = new byte[(int) lengths];// 创建字节数组
for (int i = 0; i < bt.length; i++) {
bt[i] = in.readByte();// 读取字节信息并存储到字节数组
}
receiveImg = new ImageIcon(bt).getImage();// 创建图像对象
receiveImagePanel.repaint();// 重新绘制图像
} catch (Exception e) {
} finally {
try {
if (in != null) {
in.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getServer(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 379, 260);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("路径：");
panel.add(label);

tf_path = new JTextField();
tf_path.setPreferredSize(new Dimension(140, 25));
panel.add(tf_path);

sendImagePanel = new SendImagePanel();
receiveImagePanel = new ReceiveImagePanel();
final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
JFileChooser fileChooser = new JFileChooser();// 创建文件选择器
FileFilter filter = new FileNameExtensionFilter(
"图像文件（JPG/GIF/BMP)", "JPG", "JPEG", "GIF", "BMP");// 创建过滤器
fileChooser.setFileFilter(filter);// 设置过滤器
int flag = fileChooser.showOpenDialog(null);// 显示打开对话框
if (flag == JFileChooser.APPROVE_OPTION) {
imgFile = fileChooser.getSelectedFile(); // 获取选中图片的File对象
}
if (imgFile != null) {
tf_path.setText(imgFile.getAbsolutePath());// 图片完整路径
try {
sendImg = ImageIO.read(imgFile);// 构造BufferedImage对象
} catch (IOException ex) {
ex.printStackTrace();
}
}
sendImagePanel.repaint();// 调用paint()方法
}
});
button_1.setText("选择图片");
panel.add(button_1);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
DataInputStream inStream = null;// 定义数据输入流对象
if (imgFile != null) {
lengths = imgFile.length();// 获得选择图片的大小
inStream = new DataInputStream(new FileInputStream(imgFile));// 创建输入流对象
} else {
JOptionPane.showMessageDialog(null, "还没有选择图片文件。");
return;
}
out.writeLong(lengths);// 将文件的大小写入输出流
byte[] bt = new byte[(int) lengths];// 创建字节数组
int len = -1;
while ((len = inStream.read(bt)) != -1) {// 将图片文件读取到字节数组
out.write(bt);// 将字节数组写入输出流
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
});
button.setText("发送");
panel.add(button);

final JPanel panel_1 = new JPanel();
panel_1.setLayout(new BorderLayout());
getContentPane().add(panel_1, BorderLayout.CENTER);

final JPanel panel_2 = new JPanel();
panel_2.setLayout(new GridLayout(1, 0));
final FlowLayout flowLayout = new FlowLayout();
flowLayout.setAlignment(FlowLayout.LEFT);
panel_2.setLayout(flowLayout);
panel_1.add(panel_2, BorderLayout.NORTH);

final JLabel label_1 = new JLabel();
label_1.setBorder(new EtchedBorder(EtchedBorder.LOWERED));
label_1.setText("服务器端选择的要发送的图片 ");
panel_2.add(label_1);

final JLabel label_2 = new JLabel();
label_2.setBorder(new EtchedBorder(EtchedBorder.LOWERED));
label_2.setText("接收到客户端发送的图片 ");
panel_2.add(label_2);

final JPanel imgPanel = new JPanel();
final GridLayout gridLayout = new GridLayout(1, 0);
gridLayout.setVgap(10);
imgPanel.setLayout(gridLayout);
panel_1.add(imgPanel, BorderLayout.CENTER);
imgPanel.add(sendImagePanel);
imgPanel.add(receiveImagePanel);
sendImagePanel.setBorder(new BevelBorder(BevelBorder.LOWERED));
receiveImagePanel.setBorder(new BevelBorder(BevelBorder.LOWERED));
}

// 创建面板类
class SendImagePanel extends JPanel {
public void paint(Graphics g) {
if (sendImg != null) {
g.clearRect(0, 0, this.getWidth(), this.getHeight());// 清除绘图上下文的内容
g.drawImage(sendImg, 0, 0, this.getWidth(), this.getHeight(),
this);// 绘制指定大小的图片
}
}
}

// 创建面板类
class ReceiveImagePanel extends JPanel {
public void paint(Graphics g) {
if (receiveImg != null) {
g.clearRect(0, 0, this.getWidth(), this.getHeight());// 清除绘图上下文的内容
g.drawImage(receiveImg, 0, 0, this.getWidth(),
this.getHeight(), this);// 绘制指定大小的图片
}
}
}
ClientSocketFrame.java
private Image sendImg = null; // 声明图像对象
private Image receiveImg = null; // 声明图像对象
private SendImagePanel sendImagePanel = null; // 声明图像面板对象
private ReceiveImagePanel receiveImagePanel = null; // 声明图像面板对象
private File imgFile = null;// 声明所选择图片的File对象
private JTextField tf_path;
private DataInputStream in = null; // 创建流对象
private DataOutputStream out = null; // 创建流对象
private Socket socket; // 声明Socket对象
private Container cc; // 声明Container对象
private long lengths = -1;// 图片文件的大小

private void connect() { // 连接套接字方法
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
while (true) {
if (socket != null && !socket.isClosed()) {
out = new DataOutputStream(socket.getOutputStream());// 获得输出流对象
in = new DataInputStream(socket.getInputStream());// 获得输入流对象
getServerInfo();// 调用getServerInfo()方法
} else {
socket = new Socket("192.168.1.122", 1978); // 实例化Socket对象
}
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

private void getServerInfo() {
try {
long lengths = in.readLong();// 读取图片文件的长度
byte[] bt = new byte[(int) lengths];// 创建字节数组
for (int i = 0; i < bt.length; i++) {
bt[i] = in.readByte();// 读取字节信息并存储到字节数组
}
receiveImg = new ImageIcon(bt).getImage();// 创建图像对象
receiveImagePanel.repaint();// 重新绘制图像
} catch (Exception e) {
} finally {
try {
if (in != null) {
in.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* Create the frame
*/
public ClientSocketFrame() {
super();
setTitle("客户端程序");
setBounds(100, 100, 373, 257);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("路径：");
panel.add(label);

tf_path = new JTextField();
tf_path.setPreferredSize(new Dimension(140, 25));
panel.add(tf_path);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
JFileChooser fileChooser = new JFileChooser();// 创建文件选择器
FileFilter filter = new FileNameExtensionFilter(
"图像文件（JPG/GIF/BMP)", "JPG", "JPEG", "GIF", "BMP");// 创建过滤器
fileChooser.setFileFilter(filter);// 设置过滤器
int flag = fileChooser.showOpenDialog(null);// 显示打开对话框
if (flag == JFileChooser.APPROVE_OPTION) {
imgFile = fileChooser.getSelectedFile(); // 获取选中图片的File对象
}
if (imgFile != null) {
tf_path.setText(imgFile.getAbsolutePath());// 图片完整路径
try {
sendImg = ImageIO.read(imgFile);// 构造BufferedImage对象
} catch (IOException ex) {
ex.printStackTrace();
}
}
sendImagePanel.repaint();// 调用paint()方法
}
});
button.setText("选择图片");
panel.add(button);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
DataInputStream inStream = null;// 定义数据输入流对象
if (imgFile != null) {
lengths = imgFile.length();// 获得选择图片的大小
inStream = new DataInputStream(new FileInputStream(
imgFile));// 创建输入流对象
} else {
JOptionPane.showMessageDialog(null, "还没有选择图片文件。");
return;
}
out.writeLong(lengths);// 将文件的大小写入输出流
byte[] bt = new byte[(int) lengths];// 创建字节数组
int len = -1;
while ((len = inStream.read(bt)) != -1) {// 将图片文件读取到字节数组
out.write(bt);// 将字节数组写入输出流
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
});
button_1.setText("发送");
panel.add(button_1);

final JPanel panel_1 = new JPanel();
panel_1.setLayout(new BorderLayout());
getContentPane().add(panel_1, BorderLayout.CENTER);

final JPanel panel_2 = new JPanel();
panel_2.setLayout(new GridLayout(1, 0));
panel_1.add(panel_2, BorderLayout.NORTH);

final JLabel label_1 = new JLabel();
label_1.setBorder(new EtchedBorder(EtchedBorder.LOWERED));
label_1.setText("客户端选择的要发送的图片");
panel_2.add(label_1);

final JLabel label_2 = new JLabel();
label_2.setBorder(new EtchedBorder(EtchedBorder.LOWERED));
label_2.setText("接收到服务器端发送的图片 ");
panel_2.add(label_2);

final JPanel imgPanel = new JPanel();
sendImagePanel = new SendImagePanel();
receiveImagePanel = new ReceiveImagePanel();
imgPanel.add(sendImagePanel);
imgPanel.add(receiveImagePanel);
final GridLayout gridLayout = new GridLayout(1, 0);
gridLayout.setVgap(6);
imgPanel.setLayout(gridLayout);
panel_1.add(imgPanel, BorderLayout.CENTER);
//
}

// 创建面板类
class SendImagePanel extends JPanel {
public void paint(Graphics g) {
if (sendImg != null) {
g.clearRect(0, 0, this.getWidth(), this.getHeight());// 清除绘图上下文的内容
g.drawImage(sendImg, 0, 0, this.getWidth(), this.getHeight(),
this);// 绘制指定大小的图片
}
}
}

// 创建面板类
class ReceiveImagePanel extends JPanel {
public void paint(Graphics g) {
if (receiveImg != null) {
g.clearRect(0, 0, this.getWidth(), this.getHeight());// 清除绘图上下文的内容
g.drawImage(receiveImg, 0, 0, this.getWidth(),
this.getHeight(), this);// 绘制指定大小的图片
}
}
}

实例511 使用Socket传输音频
ServerSocketFrame.java
private JTextArea ta_info;
private File file = null;// 声明所选择图片的File对象
private JTextField tf_path;
private DataOutputStream out = null; // 创建流对象
private DataInputStream in = null; // 创建流对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket
private long lengths = -1; // 图片文件的大小
private String fileName = null;

public void getServer() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
ta_info.append("客户机连接成功......\n"); // 输出信息
while (true) { // 如果套接字是连接状态
if (socket != null && !socket.isClosed()) {
out = new DataOutputStream(socket.getOutputStream());// 获得输出流对象
in = new DataInputStream(socket.getInputStream());// 获得输入流对象
getClientInfo(); // 调用getClientInfo()方法
} else {
socket = server.accept(); // 实例化Socket对象
}
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
String name = in.readUTF();// 读取文件名
long lengths = in.readLong();// 读取文件的长度
byte[] bt = new byte[(int) lengths];// 创建字节数组
for (int i = 0; i < bt.length; i++) {
bt[i] = in.readByte();// 读取字节信息并存储到字节数组
}
FileDialog dialog = new FileDialog(ServerSocketFrame.this, "保存");// 创建对话框
dialog.setMode(FileDialog.SAVE);// 设置对话框为保存对话框
dialog.setFile(name);
dialog.setVisible(true);// 显示保存对话框
String path = dialog.getDirectory();// 获得文件的保存路径
String newFileName = dialog.getFile();// 获得保存的文件名
if (path == null || newFileName == null) {
return;
}
String pathAndName = path + "\\" + newFileName;// 文件的完整路径
FileOutputStream fOut = new FileOutputStream(pathAndName);
fOut.write(bt);
fOut.flush();
fOut.close();
ta_info.append("文件接收完毕。\n");
} catch (Exception e) {
} finally {
try {
if (in != null) {
in.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getServer(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 379, 260);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("路径：");
panel.add(label);

tf_path = new JTextField();
tf_path.setPreferredSize(new Dimension(140, 25));
panel.add(tf_path);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
JFileChooser fileChooser = new JFileChooser();// 创建文件选择器
FileFilter filter = new FileNameExtensionFilter(
"音频文件（WAV/MIDI/MP3/AU)", "WAV", "MID", "MP3", "AU");// 创建过滤器
fileChooser.setFileFilter(filter);// 设置过滤器
int flag = fileChooser.showOpenDialog(null);// 显示打开对话框
if (flag == JFileChooser.APPROVE_OPTION) {
file = fileChooser.getSelectedFile(); // 获取选中音频文件的File对象
}
if (file != null) {
tf_path.setText(file.getAbsolutePath());// 音频文件的完整路径
fileName = file.getName();// 获得音频文件的名称
}
}
});
button_1.setText("选择音频");
panel.add(button_1);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
DataInputStream inStream = null;// 定义数据输入流对象
if (file != null) {
lengths = file.length();// 获得所选择音频文件的大小
inStream = new DataInputStream(
new FileInputStream(file));// 创建输入流对象
} else {
JOptionPane.showMessageDialog(null, "还没有选择音频文件。");
return;
}
out.writeUTF(fileName);// 写入音频文件名
out.writeLong(lengths);// 将文件的大小写入输出流
byte[] bt = new byte[(int) lengths];// 创建字节数组
int len = -1;
while ((len = inStream.read(bt)) != -1) {// 将音频文件读取到字节数组
out.write(bt);// 将字节数组写入输出流
}
out.flush();
out.close();
ta_info.append("文件发送完毕。\n");
} catch (IOException e1) {
e1.printStackTrace();
}
}
});
button.setText("发送");
panel.add(button);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}
ClientSocketFrame.java
private JTextArea ta_info;
private File file = null;// 声明所选择图片的File对象
private JTextField tf_path;
private DataInputStream in = null; // 创建流对象
private DataOutputStream out = null; // 创建流对象
private Socket socket; // 声明Socket对象
private long lengths = -1;// 图片文件的大小
private String fileName = null;

private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
ta_info.append("完成连接。\n"); // 文本域中提示信息
while (true) {
if (socket != null && !socket.isClosed()) {
out = new DataOutputStream(socket.getOutputStream());// 获得输出流对象
in = new DataInputStream(socket.getInputStream());// 获得输入流对象
getServerInfo();// 调用getServerInfo()方法
} else {
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
}
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

private void getServerInfo() {
try {
String name = in.readUTF();// 读取文件名
long lengths = in.readLong();// 读取文件的长度
byte[] bt = new byte[(int) lengths];// 创建字节数组
for (int i = 0; i < bt.length; i++) {
bt[i] = in.readByte();// 读取字节信息并存储到字节数组
}
FileDialog dialog = new FileDialog(ClientSocketFrame.this, "保存");// 创建对话框
dialog.setMode(FileDialog.SAVE);// 设置对话框为保存对话框
dialog.setFile(name);
dialog.setVisible(true);// 显示保存对话框
String path = dialog.getDirectory();// 获得文件的保存路径
String newFileName = dialog.getFile();// 获得保存的文件名
if (path == null || newFileName == null) {
return;
}
String pathAndName = path + "\\" + newFileName;// 文件的完整路径
FileOutputStream fOut = new FileOutputStream(pathAndName);
fOut.write(bt);
fOut.flush();
fOut.close();
ta_info.append("文件接收完毕。\n");
} catch (Exception e) {
} finally {
try {
if (in != null) {
in.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* Create the frame
*/
public ClientSocketFrame() {
super();
setTitle("客户端程序");
setBounds(100, 100, 373, 257);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("路径：");
panel.add(label);

tf_path = new JTextField();
tf_path.setPreferredSize(new Dimension(140,25));
panel.add(tf_path);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
JFileChooser fileChooser = new JFileChooser();// 创建文件选择器
FileFilter filter = new FileNameExtensionFilter("音频文件（WAV/MIDI/MP3/AU)", "WAV", "MID", "MP3", "AU");// 创建过滤器
fileChooser.setFileFilter(filter);// 设置过滤器
int flag = fileChooser.showOpenDialog(null);// 显示打开对话框
if (flag == JFileChooser.APPROVE_OPTION) {
file = fileChooser.getSelectedFile(); // 获取选中音频文件的File对象
}
if (file != null) {
tf_path.setText(file.getAbsolutePath());// 音频文件的完整路径
fileName = file.getName();// 获得音频文件的名称
}
}
});
button.setText("选择音频");
panel.add(button);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
DataInputStream inStream = null;// 定义数据输入流对象
if (file != null) {
lengths = file.length();// 获得所选择音频文件的大小
inStream = new DataInputStream(new FileInputStream(file));// 创建输入流对象
} else {
JOptionPane.showMessageDialog(null, "还没有选择音频文件。");
return;
}
out.writeUTF(fileName);// 写入音频文件名
out.writeLong(lengths);// 将文件的大小写入输出流
byte[] bt = new byte[(int) lengths];// 创建字节数组
int len = -1;// 用于存储读取到的字节数
while ((len = inStream.read(bt)) != -1) {// 将音频文件读取到字节数组
out.write(bt);// 将字节数组写入输出流
}
out.flush();// 更新输出流对象
out.close();// 关闭输出流对象
ta_info.append("文件发送完毕。\n");
} catch (IOException e1) {
e1.printStackTrace();
}
}
});
button_1.setText("发送");
panel.add(button_1);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
//
}

实例512 使用Socket传输视频
ServerSocketFrame.java
private JTextArea ta_info;
private File file = null;// 声明所选择图片的File对象
private JTextField tf_path;
private DataOutputStream out = null; // 创建流对象
private DataInputStream in = null; // 创建流对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket
private long lengths = -1; // 图片文件的大小
private String fileName = null;

public void getServer() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
ta_info.append("客户机连接成功......\n"); // 输出信息
while (true) { // 如果套接字是连接状态
if (socket != null && !socket.isClosed()) {
out = new DataOutputStream(socket.getOutputStream());// 获得输出流对象
in = new DataInputStream(socket.getInputStream());// 获得输入流对象
getClientInfo(); // 调用getClientInfo()方法
} else {
socket = server.accept(); // 实例化Socket对象
}
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
String name = in.readUTF();// 读取文件名
long lengths = in.readLong();// 读取文件的长度
byte[] bt = new byte[(int) lengths];// 创建字节数组
for (int i = 0; i < bt.length; i++) {
bt[i] = in.readByte();// 读取字节信息并存储到字节数组
}
FileDialog dialog = new FileDialog(ServerSocketFrame.this, "保存");// 创建对话框
dialog.setMode(FileDialog.SAVE);// 设置对话框为保存对话框
dialog.setFile(name);
dialog.setVisible(true);// 显示保存对话框
String path = dialog.getDirectory();// 获得文件的保存路径

String newFileName = dialog.getFile();// 获得保存的文件名
if (path == null || newFileName == null) {
return;
}
String pathAndName = path + "\\" + newFileName;// 文件的完整路径
FileOutputStream fOut = new FileOutputStream(pathAndName);
fOut.write(bt);
fOut.flush();
fOut.close();
ta_info.append("文件接收完毕。");
} catch (Exception e) {
} finally {
try {
if (in != null) {
in.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getServer(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 379, 260);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("路径：");
panel.add(label);

tf_path = new JTextField();
tf_path.setPreferredSize(new Dimension(140, 25));
panel.add(tf_path);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
JFileChooser fileChooser = new JFileChooser();// 创建文件选择器
FileFilter filter = new FileNameExtensionFilter(
"视频文件（AVI/MPG/DAT/RM)", "AVI", "MPG", "DAT", "RM");// 创建过滤器
fileChooser.setFileFilter(filter);// 设置过滤器
int flag = fileChooser.showOpenDialog(null);// 显示打开对话框
if (flag == JFileChooser.APPROVE_OPTION) {
file = fileChooser.getSelectedFile(); // 获取选中视频文件的File对象
}
if (file != null) {
tf_path.setText(file.getAbsolutePath());// 视频文件的完整路径
fileName = file.getName();// 获得视频文件的名称
}
}
});
button_1.setText("选择视频");
panel.add(button_1);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
DataInputStream inStream = null;// 定义数据输入流对象
if (file != null) {
lengths = file.length();// 获得所选择视频文件的大小
inStream = new DataInputStream(
new FileInputStream(file));// 创建输入流对象
} else {
JOptionPane.showMessageDialog(null, "还没有选择视频文件。");
return;
}
out.writeUTF(fileName);// 写入视频文件名
out.writeLong(lengths);// 将文件的大小写入输出流
byte[] bt = new byte[(int) lengths];// 创建字节数组
int len = -1;
while ((len = inStream.read(bt)) != -1) {// 将视频文件读取到字节数组
out.write(bt);// 将字节数组写入输出流
}
out.flush();
out.close();
ta_info.append("文件发送完毕。");
} catch (IOException e1) {
e1.printStackTrace();
}
}
});
button.setText("发送");
panel.add(button);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}
ClientSocketFrame.java
private JTextArea ta_info;
private File file = null;// 声明所选择视频的File对象
private JTextField tf_path;
private DataInputStream in = null; // 创建流对象
private DataOutputStream out = null; // 创建流对象
private Socket socket; // 声明Socket对象
private long lengths = -1;// 图片文件的大小
private String fileName = null;

private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
ta_info.append("完成连接。\n"); // 文本域中提示信息
while (true) {
if (socket != null && !socket.isClosed()) {
out = new DataOutputStream(socket.getOutputStream());// 获得输出流对象
in = new DataInputStream(socket.getInputStream());// 获得输入流对象
getServerInfo();// 调用getServerInfo()方法
} else {
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
}
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

private void getServerInfo() {
try {
String name = in.readUTF();// 读取文件名
long lengths = in.readLong();// 读取文件的长度
byte[] bt = new byte[(int) lengths];// 创建字节数组
for (int i = 0; i < bt.length; i++) {
bt[i] = in.readByte();// 读取字节信息并存储到字节数组
}
FileDialog dialog = new FileDialog(ClientSocketFrame.this, "保存");// 创建对话框
dialog.setMode(FileDialog.SAVE);// 设置对话框为保存对话框
dialog.setFile(name);
dialog.setVisible(true);// 显示保存对话框
String path = dialog.getDirectory();// 获得文件的保存路径
String newFileName = dialog.getFile();// 获得保存的文件名
if (path == null || newFileName == null) {
return;
}
String pathAndName = path + "\\" + newFileName;// 文件的完整路径
FileOutputStream fOut = new FileOutputStream(pathAndName);
fOut.write(bt);
fOut.flush();
fOut.close();
ta_info.append("文件接收完毕。");
} catch (Exception e) {
} finally {
try {
if (in != null) {
in.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* Create the frame
*/
public ClientSocketFrame() {
super();
setTitle("客户端程序");
setBounds(100, 100, 373, 257);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setText("路径：");
panel.add(label);

tf_path = new JTextField();
tf_path.setPreferredSize(new Dimension(140,25));
panel.add(tf_path);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
JFileChooser fileChooser = new JFileChooser();// 创建文件选择器
FileFilter filter = new FileNameExtensionFilter("视频文件（AVI/MPG/DAT/RM)", "AVI", "MPG", "DAT", "RM");// 创建过滤器
fileChooser.setFileFilter(filter);// 设置过滤器
int flag = fileChooser.showOpenDialog(null);// 显示打开对话框
if (flag == JFileChooser.APPROVE_OPTION) {
file = fileChooser.getSelectedFile(); // 获取选中视频文件的File对象
}
if (file != null) {
tf_path.setText(file.getAbsolutePath());// 视频文件的完整路径
fileName = file.getName();// 获得视频文件的名称
}
}
});
button.setText("选择视频");
panel.add(button);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
DataInputStream inStream = null;// 定义数据输入流对象
if (file != null) {
lengths = file.length();// 获得所选择视频文件的大小
inStream = new DataInputStream(new FileInputStream(file));// 创建输入流对象
} else {
JOptionPane.showMessageDialog(null, "还没有选择视频文件。");
return;
}
out.writeUTF(fileName);// 写入视频文件名
out.writeLong(lengths);// 将文件的大小写入输出流
byte[] bt = new byte[(int) lengths];// 创建字节数组
int len = -1;
while ((len = inStream.read(bt)) != -1) {// 将视频文件读取到字节数组
out.write(bt);// 将字节数组写入输出流
}
out.flush();
out.close();
ta_info.append("文件发送完毕。");
} catch (IOException e1) {
e1.printStackTrace();
}
}
});
button_1.setText("发送");
panel.add(button_1);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
//
}

实例513 一个服务器与一个客户端通信
ServerSocketFrame.java
private JTextField tf_send;
private JTextArea ta_info;
private PrintWriter writer; // 声明PrintWriter类对象
private BufferedReader reader; // 声明BufferedReader对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public void getServer() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream())); // 实例化BufferedReader对象
writer = new PrintWriter(socket.getOutputStream(), true);
getClientInfo(); // 调用getClientInfo()方法
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
while (true) {
String line = reader.readLine();// 读取客户端发送的信息
if (line != null)
ta_info.append("接收到客户机发送的信息：" + line + "\n"); // 显示客户端发送的信息
}
} catch (Exception e) {
ta_info.append("客户端已退出。\n"); // 输出异常信息
} finally {
try {
if (reader != null) {
reader.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);
frame.getServer(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 379, 260);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);

final JLabel label = new JLabel();
label.setText("服务器发送的信息：");
panel.add(label);

tf_send = new JTextField();
tf_send.setPreferredSize(new Dimension(150, 25));
panel.add(tf_send);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
writer.println(tf_send.getText()); // 将文本框中信息写入流
ta_info.append("服务器发送的信息是：" + tf_send.getText() + "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(""); // 将文本框清空
}
});
button.setText("发送");
panel.add(button);

final JPanel panel_1 = new JPanel();
getContentPane().add(panel_1, BorderLayout.NORTH);

final JLabel label_1 = new JLabel();
label_1.setForeground(new Color(0, 0, 255));
label_1.setFont(new Font("", Font.BOLD, 22));
label_1.setText("一对一通信——服务器端程序");
panel_1.add(label_1);
}
ClientSocketFrame.java
private PrintWriter writer; // 声明PrintWriter类对象
private BufferedReader reader; // 声明BufferedReader对象
private Socket socket; // 声明Socket对象
private JTextArea ta_info; // 创建JtextArea对象
private JTextField tf_send; // 创建JtextField对象
private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
while (true) {
writer = new PrintWriter(socket.getOutputStream(), true);
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream())); // 实例化BufferedReader对象
ta_info.append("完成连接。\n"); // 文本域中提示信息
getServerInfo();
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

private void getServerInfo() {
try {
while (true) {
if (reader != null) {
String line = reader.readLine();// 读取服务器发送的信息
if (line != null)
ta_info.append("接收到服务器发送的信息：" + line + "\n"); // 显示服务器端发送的信息
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (reader != null) {
reader.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* Create the frame
*/
public ClientSocketFrame() {
super();
setTitle("客户端程序");
setBounds(100, 100, 361, 257);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 22));
label.setText("一对一通信——客户端程序");
panel.add(label);

final JPanel panel_1 = new JPanel();
getContentPane().add(panel_1, BorderLayout.SOUTH);

final JLabel label_1 = new JLabel();
label_1.setText("客户端发送的信息：");
panel_1.add(label_1);

tf_send = new JTextField();
tf_send.setPreferredSize(new Dimension(140, 25));
panel_1.add(tf_send);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
writer.println(tf_send.getText()); // 将文本框中信息写入流
ta_info.append("客户端发送的信息是：" + tf_send.getText()
+ "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(""); // 将文本框清空
}
});
button.setText("发送");
panel_1.add(button);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
//
}

实例514 一个服务器与多个客户端通信
ServerSocketFrame.java
private JTextField tf_send;
private JTextArea ta_info;
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket
private Vector<Socket> vector = new Vector<Socket>();// 用于存储连接到服务器的客户端套接字对象
private int counts = 0;// 用于记录连接的客户人数

public void getServer() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
socket = server.accept(); // 实例化Socket对象
counts++;
ta_info.append("第" + counts + "个客户连接成功\n"); // 输出信息
PrintWriter out = new PrintWriter(socket.getOutputStream(),
true);
out.println(String.valueOf(counts - 1));// 向客户端发送套接字索引
vector.add(socket);// 存储客户端套接字对象
new ServerThread(socket).start();// 创建并启动线程序
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

class ServerThread extends Thread {
Socket socket = null; // 创建Socket对象
BufferedReader reader; // 声明BufferedReader对象

public ServerThread(Socket socket) { // 构造方法
this.socket = socket;
}

public void run() {
try {
if (socket != null) {
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream())); // 实例化BufferedReader对象
int index = -1;// 存储退出的客户端索引值
try {
while (true) { // 如果套接字是连接状态
String line = reader.readLine();// 读取客户端信息
try {
index = Integer.parseInt(line);// 获得退出的客户端索引值
} catch (Exception ex) {
index = -1;
}
if (line != null) {
ta_info.append("接收到客户机发送的信息：" + line + "\n"); // 获得客户端信息
}
}
} catch (Exception e) {
if (index != -1) {
vector.set(index, null);// 将退出的客户端套接字设置为null
ta_info.append("第" + (index + 1) + "个客户端已经退出。\n"); // 输出异常信息
}
} finally {
try {
if (reader != null) {
reader.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

}

private void writeInfo(PrintWriter writer, String text) {
writer.println(text);
}

public static void main(String[] args) { // 主方法
ServerSocketFrame frame = new ServerSocketFrame(); // 创建本类对象
frame.setVisible(true);// 显示窗体
frame.getServer(); // 调用方法
}

public ServerSocketFrame() {
super();
setTitle("服务器端程序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 379, 260);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);

final JLabel label = new JLabel();
label.setText("服务器发送的信息：");
panel.add(label);

tf_send = new JTextField();
tf_send.setPreferredSize(new Dimension(150, 25));
panel.add(tf_send);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
for (int i = 0; i < vector.size(); i++) {
Socket socket = vector.get(i);// 获得连接成功的套接字对象
PrintWriter writer;
try {
if (socket != null && !socket.isClosed()) {
writer = new PrintWriter(socket.getOutputStream(),
true);// 创建输出流对象
writeInfo(writer, tf_send.getText()); // 将文本框中信息写入流
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
ta_info.append("服务器发送的信息是：" + tf_send.getText() + "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(""); // 将文本框清空
}
});
button.setText("发送");
panel.add(button);

final JPanel panel_1 = new JPanel();
getContentPane().add(panel_1, BorderLayout.NORTH);

final JLabel label_1 = new JLabel();
label_1.setForeground(new Color(0, 0, 255));
label_1.setFont(new Font("", Font.BOLD, 22));
label_1.setText("一对多通信——服务器端程序");
panel_1.add(label_1);
}
ClientSocketFrame.java
private PrintWriter writer; // 声明PrintWriter类对象
private BufferedReader reader; // 声明BufferedReader对象
private Socket socket; // 声明Socket对象
private JTextArea ta_info; // 创建JtextArea对象
private JTextField tf_send; // 创建JtextField对象
private int index = -1;
private void connect() { // 连接套接字方法
ta_info.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
while (true) {
writer = new PrintWriter(socket.getOutputStream(), true);// 创建输出流对象
reader = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 实例化BufferedReader对象
index = Integer.parseInt(reader.readLine());// 获得客户登录服务器的索引值
ta_info.append("你是第"+(index+1)+"个完成连接的用户。\n"); // 文本域中提示信息
getServerInfo();
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

public static void main(String[] args) { // 主方法
ClientSocketFrame clien = new ClientSocketFrame(); // 创建本例对象
clien.setVisible(true); // 将窗体显示
clien.connect(); // 调用连接方法
}

private void getServerInfo() {
try {
while (true) { // 如果套接字是连接状态
if (reader != null) {
String line = reader.readLine();// 读取服务器发送的信息
if (line != null){
ta_info.append("接收到服务器发送的信息：" + line + "\n"); // 获得客户端信息
}
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (reader != null) {
reader.close();// 关闭流
}
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* Create the frame
*/
public ClientSocketFrame() {
super();
addWindowListener(new WindowAdapter() {
public void windowClosing(final WindowEvent e) {
writer.println(String.valueOf(index));// 向服务器端发送退出客户的索引值
}
});
setTitle("客户端程序");
setBounds(100, 100, 361, 257);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.NORTH);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 22));
label.setText("一对多通信——客户端程序");
panel.add(label);

final JPanel panel_1 = new JPanel();
getContentPane().add(panel_1, BorderLayout.SOUTH);

final JLabel label_1 = new JLabel();
label_1.setText("客户端发送的信息：");
panel_1.add(label_1);

tf_send = new JTextField();
tf_send.setPreferredSize(new Dimension(140, 25));
panel_1.add(tf_send);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
writer.println(tf_send.getText()); // 将文本框中信息写入流
ta_info.append("客户端发送的信息是：" + tf_send.getText()
+ "\n"); // 将文本框中信息显示在文本域中
tf_send.setText(""); // 将文本框清空
}
});
button.setText("发送");
panel_1.add(button);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
//
}

实例515 客户端一对多通信
ClientOneToMany_ServerFrame.java
private JTextArea ta_info;
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket
private Vector<Socket> vector = new Vector<Socket>();// 用于存储连接到服务器的客户端套接字对象

public void createSocket() {
try {
server = new ServerSocket(1978);
while (true) {
ta_info.append("等待新客户连接......\n");
socket = server.accept();// 创建套接字对象
vector.add(socket);// 将套接字对象添加到向量对象中
ta_info.append("客户端连接成功。" + socket + "\n");
new ServerThread(socket).start();// 创建并启动线程对象
}
} catch (IOException e) {
e.printStackTrace();
}
}

class ServerThread extends Thread {
Socket socket;
public ServerThread(Socket socket) {
this.socket = socket;
}
public void run() {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));// 创建输入流对象
while (true) {
String info = in.readLine();// 读取信息
for (Socket s : vector) {// 遍历所有客户端套接字对象
if (s != socket) {// 如果不是发送信息的套接字对象
PrintWriter out = new PrintWriter(s
.getOutputStream(), true);// 创建输出流对象
out.println(info);// 发送信息
out.flush();// 刷新输出缓冲区
}
}
}
} catch (IOException e) {
ta_info.append(socket + "已经退出。\n");
vector.remove(socket);// 移除退出的客户端套接字
}
}
}

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
ClientOneToMany_ServerFrame frame = new ClientOneToMany_ServerFrame();
frame.setVisible(true);
frame.createSocket();
}

/**
* Create the frame
*/
public ClientOneToMany_ServerFrame() {
super();
setTitle("客户端一对多通信——服务器端程序");
setBounds(100, 100, 385, 266);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}
ClientOneToMany_ClientFrame.java
private JTextArea ta_info;
private JTextField tf_send;
PrintWriter out;// 声明输出流对象

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ClientOneToMany_ClientFrame frame = new ClientOneToMany_ClientFrame();
frame.setVisible(true);
frame.createClientSocket();
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

public void createClientSocket() {
try {
Socket socket = new Socket("192.168.1.193", 1978);// 创建套接字对象
out = new PrintWriter(socket.getOutputStream(), true);// 创建输出流对象
new ClientThread(socket).start();// 创建并启动线程对象
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

class ClientThread extends Thread {
Socket socket;

public ClientThread(Socket socket) {
this.socket = socket;
}

public void run() {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));// 创建输入流对象
while (true) {
String info = in.readLine();// 读取信息
ta_info.append(info + "\n");// 在文本域中显示信息
if (info.equals("88")) {
break;// 结束线程
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void send() {
String info = tf_send.getText();// 获得输入的信息
if (info.equals("")) {
return;// 如果没输入信息则返回，即不发送
}
if (info.equals("88")) {
System.exit(0);// 如果没输入信息是88，则退出
}
out.println(info);// 发送信息
out.flush();// 刷新输出缓冲区
tf_send.setText(null);// 清空文本框
}
/**
* Create the frame
*/
public ClientOneToMany_ClientFrame() {
super();
setTitle("客户端一对多通信——客户端程序");
setBounds(100, 100, 385, 266);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);

final JLabel label = new JLabel();
label.setText("输入聊天内容：");
panel.add(label);

tf_send = new JTextField();
tf_send.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
send();// 调用方法发送信息
}
});
tf_send.setPreferredSize(new Dimension(180, 25));
panel.add(tf_send);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
send();// 调用方法发送信息
}
});
button.setText("发送");
panel.add(button);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
//
}

实例516 客户端一对一通信
ClientOneToOne_ServerFrame.java
private JTextArea ta_info;
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket
private Hashtable<String, Socket> map = new Hashtable<String, Socket>();// 用于存储连接到服务器的用户和客户端套接字对象

public void createSocket() {
try {
server = new ServerSocket(1978);
while (true) {
ta_info.append("等待新客户连接......\n");
socket = server.accept();// 创建套接字对象
ta_info.append("客户端连接成功。" + socket + "\n");
new ServerThread(socket).start();// 创建并启动线程对象
}
} catch (IOException e) {
e.printStackTrace();
}
}

class ServerThread extends Thread {
Socket socket;

public ServerThread(Socket socket) {
this.socket = socket;
}

public void run() {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));// 创建输入流对象
while (true) {
String info = in.readLine();// 读取信息
String key = "";
if (info.startsWith("用户：")) {// 添加登录用户到客户端列表
key = info.substring(3, info.length());// 获得用户名并作为键使用
map.put(key, socket);// 添加键值对
Set<String> set = map.keySet();// 获得集合中所有键的Set视图
Iterator<String> keyIt = set.iterator();// 获得所有键的迭代器
while (keyIt.hasNext()) {
String receiveKey = keyIt.next();// 获得表示接收信息的键
Socket s = map.get(receiveKey);// 获得与该键对应的套接字对象
PrintWriter out = new PrintWriter(s
.getOutputStream(), true);// 创建输出流对象
Iterator<String> keyIt1 = set.iterator();// 获得所有键的迭代器
while (keyIt1.hasNext()) {
String receiveKey1 = keyIt1.next();// 获得键，用于向客户端添加用户列表
out.println(receiveKey1);// 发送信息
out.flush();// 刷新输出缓冲区
}
}

} else {// 转发接收的消息
key = info.substring(info.indexOf("：发送给：") + 5, info
.indexOf("：的信息是："));// 获得接收方的key值,即接收方的用户名
String sendUser = info.substring(0, info
.indexOf("：发送给："));// 获得发送方的key值,即发送方的用户名
Set<String> set = map.keySet();// 获得集合中所有键的Set视图
Iterator<String> keyIt = set.iterator();// 获得所有键的迭代器
while (keyIt.hasNext()) {
String receiveKey = keyIt.next();// 获得表示接收信息的键
if (key.equals(receiveKey)
&& !sendUser.equals(receiveKey)) {// 如果是发送方，但不是用户本身
Socket s = map.get(receiveKey);// 获得与该键对应的套接字对象
PrintWriter out = new PrintWriter(s
.getOutputStream(), true);// 创建输出流对象

out.println("MSG:"+info);// 发送信息
out.flush();// 刷新输出缓冲区
}
}
}
}
} catch (IOException e) {
ta_info.append(socket + "已经退出。\n");
}
}
}

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
ClientOneToOne_ServerFrame frame = new ClientOneToOne_ServerFrame();
frame.setVisible(true);
frame.createSocket();
}

/**
* Create the frame
*/
public ClientOneToOne_ServerFrame() {
super();
setTitle("客户端一对一通信——服务器端程序");
setBounds(100, 100, 385, 266);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
}
ClientOneToOne_ClientFrame.java
private JTextField tf_newUser;
private JList user_list;
private JTextArea ta_info;
private JTextField tf_send;
PrintWriter out;// 声明输出流对象
private boolean loginFlag = false;// 为true时表示已经登录，为false时表示未登录

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ClientOneToOne_ClientFrame frame = new ClientOneToOne_ClientFrame();
frame.setVisible(true);
frame.createClientSocket();// 调用方法创建套接字对象
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

public void createClientSocket() {
try {
Socket socket = new Socket("192.168.1.193", 1978);// 创建套接字对象
out = new PrintWriter(socket.getOutputStream(), true);// 创建输出流对象
new ClientThread(socket).start();// 创建并启动线程对象
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

class ClientThread extends Thread {
Socket socket;

public ClientThread(Socket socket) {
this.socket = socket;
}

public void run() {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));// 创建输入流对象
DefaultComboBoxModel model = (DefaultComboBoxModel) user_list
.getModel();// 获得列表框的模型
while (true) {
String info = in.readLine().trim();// 读取信息

if (!info.startsWith("MSG:")) {
boolean itemFlag = false;// 标记是否为列表框添加列表项，为true不添加，为false添加
for (int i = 0; i < model.getSize(); i++) {
if (info.equals((String) model.getElementAt(i))) {
itemFlag = true;
}
}
if (!itemFlag) {
model.addElement(info);// 添加列表项
} else {
itemFlag = false;
}
} else {
ta_info.append(info + "\n");// 在文本域中显示信息
if (info.equals("88")) {
break;// 结束线程
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

private void send() {
if (!loginFlag) {
JOptionPane.showMessageDialog(null, "请先登录。");
return;
}
String sendUserName = tf_newUser.getText().trim();
String info = tf_send.getText();// 获得输入的信息
if (info.equals("")) {
return;// 如果没输入信息则返回，即不发送
}
String receiveUserName = (String) user_list.getSelectedValue();// 获得接收信息的用户
String msg = sendUserName + "：发送给：" + receiveUserName + "：的信息是： "
+ info;// 定义发送的信息
if (info.equals("88")) {
System.exit(0);// 如果没输入信息是88，则退出
}
out.println(msg);// 发送信息
out.flush();// 刷新输出缓冲区
tf_send.setText(null);// 清空文本框
}

/**
* Create the frame
*/
public ClientOneToOne_ClientFrame() {
super();
setTitle("客户端一对一通信——客户端程序");
setBounds(100, 100, 385, 288);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);

final JLabel label = new JLabel();
label.setText("输入聊天内容：");
panel.add(label);

tf_send = new JTextField();
tf_send.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
send();// 调用方法发送信息
}
});
tf_send.setPreferredSize(new Dimension(180, 25));
panel.add(tf_send);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
send();// 调用方法发送信息
}
});
button.setText("发送");
panel.add(button);

final JSplitPane splitPane = new JSplitPane();
splitPane.setDividerLocation(100);
getContentPane().add(splitPane, BorderLayout.CENTER);

final JScrollPane scrollPane = new JScrollPane();
splitPane.setRightComponent(scrollPane);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);

final JScrollPane scrollPane_1 = new JScrollPane();
splitPane.setLeftComponent(scrollPane_1);

user_list = new JList();
user_list.setModel(new DefaultComboBoxModel(new String[] { "" }));
scrollPane_1.setViewportView(user_list);

final JPanel panel_1 = new JPanel();
getContentPane().add(panel_1, BorderLayout.NORTH);

final JLabel label_1 = new JLabel();
label_1.setText("输入用户名称：");
panel_1.add(label_1);

tf_newUser = new JTextField();
tf_newUser.setPreferredSize(new Dimension(180, 25));
panel_1.add(tf_newUser);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
if (loginFlag) {
JOptionPane.showMessageDialog(null, "在同一窗口只能登录一次。");
return;
}
String userName = tf_newUser.getText().trim();// 获得登录用户名
out.println("用户：" + userName);// 发送登录用户的名称
out.flush();// 刷新输出缓冲区
tf_newUser.setEnabled(false);
loginFlag = true;
}
});
button_1.setText("登录");
panel_1.add(button_1);
}

实例517 基于Socket的数据库编程
DAO.java
private static DAO dao = new DAO(); // 声明DAO类的静态实例
/**
* 构造方法，加载数据库驱动
*/
public DAO() {
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); // 加载数据库驱动
} catch (ClassNotFoundException e) {
JOptionPane.showMessageDialog(null, "数据库驱动加载失败。\n"
+ e.getMessage());
}
}

/**
* 获得数据库连接的方法
*
* @return Connection
*/
public static Connection getConn() {
try {
Connection conn = null; // 定义数据库连接
String url = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=database/db_picture.mdb"; // 数据库db_picture.mdb的URL
String username = ""; // 数据库的用户名
String password = ""; // 数据库密码
conn = DriverManager.getConnection(url, username, password); // 建立连接
return conn; // 返回连接
} catch (Exception e) {
JOptionPane.showMessageDialog(null,
"数据库连接失败。\n" + e.getMessage());
return null;
}
}
DatabaseClientFrame.java
private JTextArea ta_result;
private JTextField tf_age;
private JTextField tf_name;
private PrintWriter writer; // 声明PrintWriter类对象
private BufferedReader reader; // 声明BufferedReader对象
private Socket socket; // 声明Socket对象

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
DatabaseClientFrame frame = new DatabaseClientFrame();
frame.setVisible(true);
frame.connect();
}

private void connect() { // 连接套接字方法
ta_result.append("尝试连接......\n"); // 文本域中信息信息
try { // 捕捉异常
socket = new Socket("192.168.1.193", 1978); // 实例化Socket对象
while (true) {
writer = new PrintWriter(socket.getOutputStream(), true);// 实例化PrintWriter对象
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream())); // 实例化BufferedReader对象
ta_result.append("完成连接。\n"); // 文本域中提示信息
getServerInfo();// 调用方法读取服务器信息
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getServerInfo() {
try {
while (true) { // 如果套接字是连接状态
if (reader != null) {
String line = reader.readLine();// 读取服务器信息
if (line != null) {
ta_result.append("接收到服务器发送的信息： " + line + "\n"); // 获得服务器信息
}
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* Create the frame
*/
public DatabaseClientFrame() {
super();
getContentPane().setLayout(null);
setTitle("客户端程序");
setBounds(100, 100, 277, 263);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();
label.setText("名称：");
label.setBounds(10, 12, 66, 18);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("年龄：");
label_1.setBounds(10, 38, 66, 18);
getContentPane().add(label_1);

tf_name = new JTextField();
tf_name.setBounds(56, 10, 194, 22);
getContentPane().add(tf_name);

tf_age = new JTextField();
tf_age.setBounds(56, 36, 194, 22);
getContentPane().add(tf_age);

final JPanel panel = new JPanel();
panel.setLayout(null);
panel.setBorder(new TitledBorder(null, "显示服务器端的反馈信息",
TitledBorder.DEFAULT_JUSTIFICATION,
TitledBorder.DEFAULT_POSITION, null, null));
panel.setBounds(10, 91, 240, 124);
getContentPane().add(panel);

final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 21, 220, 93);
panel.add(scrollPane);

ta_result = new JTextArea();
scrollPane.setViewportView(ta_result);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
String name = tf_name.getText().trim();// 获得姓名
String age = tf_age.getText().trim();// 获得年龄
if (name == null || name.equals("") || age == null || age.equals("")) {
JOptionPane.showMessageDialog(null, "姓名和年龄不能为空。");
return;
}
try {
Integer.parseInt(age);// 如果年龄不是数字就会发生异常
}catch(Exception ex) {
JOptionPane.showMessageDialog(null, "年龄必须为数字。");
return;
}
String info = name + ":data:" + age;// 使用字符串":data:"连接姓名和年龄
writer.println(info);// 向服务器发送信息
}
});
button.setText("保存");
button.setBounds(41, 62, 72, 23);
getContentPane().add(button);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
System.exit(0);
}
});
button_1.setText("退出");
button_1.setBounds(148, 62, 72, 23);
getContentPane().add(button_1);
//
}
DatabaseServerFrame.java
private JTextArea ta_info;
private PrintWriter writer; // 声明PrintWriter类对象
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket

public void getserver() {
try {
server = new ServerSocket(1978); // 实例化Socket对象
ta_info.append("服务器套接字已经创建成功\n"); // 输出信息
while (true) { // 如果套接字是连接状态
ta_info.append("等待客户机的连接......\n"); // 输出信息
socket = server.accept(); // 实例化Socket对象
writer = new PrintWriter(socket.getOutputStream(), true);// 创建输出流对象
getClientInfo(); // 调用getClientInfo()方法
}
} catch (Exception e) {
e.printStackTrace(); // 输出异常信息
}
}

private void getClientInfo() {
try {
BufferedReader reader; // 声明BufferedReader对象
while (true) { // 如果套接字是连接状态
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream())); // 实例化BufferedReader对象
String line = reader.readLine();// 读取客户端信息
if (line != null) {
String[] value = new String[2];// 创建数组
value[0] = line.substring(0, line.indexOf(":data:"));// 获得姓名
value[1] = line.substring(line.indexOf(":data:") + 6);// 获得年龄
ta_info.append("接收到客户端的信息\n姓名为："+value[0]+" 年龄为："+value[1]+"。\n");
try {
Connection conn = DAO.getConn();// 获得数据库连接
String sql = "insert into tb_employee (name,age) values(?,?)";// 定义SQL语句
PreparedStatement ps = conn.prepareStatement(sql);// 创建PreparedStatement对象，并传递SQL语句
ps.setString(1, value[0]); // 为第1个参数赋值
ps.setInt(2, Integer.parseInt(value[1]));// 为第2个参数赋值
int flag = ps.executeUpdate(); // 执行SQL语句，获得更新记录数
ps.close();// 关闭PreparedStatement对象
conn.close();// 关闭连接
if (flag > 0) {
ta_info.append("并成功地保存到数据库中。\n");
writer.println("保存成功。");// 向客户端输出保存成功的信息
} else {
writer.println("保存失败。\n");// 向客户端输出保存成功的信息
}
} catch (SQLException ee) {
writer.println("保存失败。\n" + ee.getMessage());// 向客户端输出保存成功的信息
}
}
}
} catch (Exception e) {
ta_info.append("客户端已退出。\n");
} finally {
try {
if (socket != null) {
socket.close(); // 关闭套接字
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
DatabaseServerFrame frame = new DatabaseServerFrame();
frame.setVisible(true);
frame.getserver(); // 调用方法
}

/**
* Create the frame
*/
public DatabaseServerFrame() {
super();
getContentPane().setLayout(null);
setTitle("服务器端程序");
setBounds(100, 100, 277, 263);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 10, 241, 205);
getContentPane().add(scrollPane);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
//
}

实例518 使用Proxy创建代理服务器
private JTextArea ta_show;
private JTextField tf_accessAddress;
private JTextField tf_proxyPort;
private JTextField tf_proxyAddress;
private Proxy proxy;// 定义代理
private URL url;// 定义URL对象
private URLConnection urlConn;// 定义连接对象
private Scanner scanner;// 在网络中通过代理读取数据的扫描器

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
UserProxyFrame frame = new UserProxyFrame();
frame.setVisible(true);
}

public void accessUrl(String proxyAddress, int proxyPort,
String accessAddress) throws Exception {
url = new URL(accessAddress);// 创建URL对象
proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyAddress,
proxyPort));// 创建代理
urlConn = url.openConnection(proxy);// 通过代理打开连接
scanner = new Scanner(urlConn.getInputStream(), "UTF8");// 通过流创建扫描器
ta_show.setText(null);// 清空文本域的内容
StringBuffer sb = new StringBuffer();// 创建字符串缓存
while (scanner.hasNextLine()) {// 判断扫描器是否有数据
String line = scanner.nextLine();// 从扫描器获得一行数据
sb.append(line + "\n");// 向字符串缓存添加信息
}
if (sb != null) {
ta_show.append(sb.toString());// 在文本域中显示信息
}
}

/**
* Create the frame
*/
public UserProxyFrame() {
super();
getContentPane().setLayout(null);
setTitle("使用Proxy创建代理服务器");
setBounds(100, 100, 448, 334);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();
label.setText("代理服务器的地址：");
label.setBounds(10, 10, 129, 18);
getContentPane().add(label);

tf_proxyAddress = new JTextField();
tf_proxyAddress.setBounds(145, 8, 277, 22);
getContentPane().add(tf_proxyAddress);

final JLabel label_1 = new JLabel();
label_1.setText("代理服务器的端口号：");
label_1.setBounds(10, 38, 136, 18);
getContentPane().add(label_1);

tf_proxyPort = new JTextField();
tf_proxyPort.setBounds(145, 36, 277, 22);
getContentPane().add(tf_proxyPort);

final JLabel label_2 = new JLabel();
label_2.setText("输入要访问的网站网址，然后回车");
label_2.setBounds(10, 65, 231, 18);
getContentPane().add(label_2);

tf_accessAddress = new JTextField();
tf_accessAddress.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
String proxyAddress = tf_proxyAddress.getText().trim();// 代理服务器的地址
int proxyPort = Integer.parseInt(tf_proxyPort.getText().trim());// 代理服务器的端口
String accessAddress = tf_accessAddress.getText().trim();// 需要打开的网站网址
accessUrl(proxyAddress, proxyPort, accessAddress);// 调用方法，使用代理访问网站
} catch (Exception ex) {
JOptionPane.showMessageDialog(null, "输入的信息有误。");
}
}
});
tf_accessAddress.setBounds(10, 85, 412, 22);
getContentPane().add(tf_accessAddress);

final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 137, 412, 149);
getContentPane().add(scrollPane);

ta_show = new JTextArea();
scrollPane.setViewportView(ta_show);

final JLabel label_3 = new JLabel();
label_3.setText("访问结果");
label_3.setBounds(10, 113, 193, 18);
getContentPane().add(label_3);
}

实例519 使用ProxySelector选择代理服务器
private JTextArea ta_info;
private JTextField tf_accessAddress;
private JTextField tf_proxyAddress;

/**
* Launch the application
*
* @param args
*/
public static void main(String args[]) {
ProxySelectorFrame frame = new ProxySelectorFrame();
frame.setVisible(true);
}

public void setProxyInfo(String proxyAddress) {
Properties propperties = System.getProperties();// 获得系统属性对象
propperties.setProperty("http.proxyHost", proxyAddress);// 设置HTTP服务使用的代理服务器地址
propperties.setProperty("http.proxyPort", "80");// 设置HTTP服务使用的代理服务器端口
propperties.setProperty("https.proxyHost", proxyAddress);// 设置安全HTTP服务使用的代理服务器地址
propperties.setProperty("https.proxyPort", "443");// 设置安全HTTP服务使用的代理服务器端口
propperties.setProperty("ftp.proxyHost", proxyAddress);// 设置FTP访问的代理服务器主机
propperties.setProperty("ftp.proxyPort", "21");// 设置FTP访问的代理服务器端口
propperties.setProperty("socks.ProxyHost", proxyAddress);// 设置socks代理服务器的地址
propperties.setProperty("socks.ProxyPort", "1080");// 设置socks代理服务器的端口
}

public void removeProxyInfo() {
Properties propperties = System.getProperties();// 获得系统属性对象
propperties.remove("http.proxyHost");// 清除HTTP服务使用的代理服务器地址
propperties.remove("http.proxyPort");// 清除HTTP服务使用的代理服务器端口
propperties.remove("https.proxyHost");// 清除安全HTTP服务使用的代理服务器地址
propperties.remove("https.proxyPort");// 清除安全HTTP服务使用的代理服务器端口
propperties.remove("ftp.proxyHost");// 清除FTP访问的代理服务器主机
propperties.remove("ftp.proxyPort");// 清除FTP访问的代理服务器端口
propperties.remove("socksProxyHost");// 清除socks代理服务器的地址
propperties.remove("socksProxyPort");// 清除socks代理服务器的端口
}

/**
* 使用HTTP访问
* @param accessAddress 需要访问的地址
* @throws Exception 抛出异常
*/
public void useHttpAccess(String accessAddress) throws Exception{
URL url = new URL(accessAddress);// 创建URL对象
URLConnection urlConn = url.openConnection(); // 自动调用系统设置的HTTP代理服务器，并打开连接
Scanner scanner = new Scanner(urlConn.getInputStream(),"utf8");// 通过流创建扫描对象
StringBuffer sb = new StringBuffer();// 创建字符器缓存
while (scanner.hasNextLine()) {// 如果扫描器中有信息
sb.append(scanner.nextLine()+"\n");// 读取代理服务器上的网页内容，并添加到字符串缓存中
}
if (sb!=null) {
ta_info.append(sb.toString());// 显示网页内容
}
}

/**
* Create the frame
*/
public ProxySelectorFrame() {
super();
setTitle("使用ProxySelector选择代理服务器");
getContentPane().setLayout(null);
setBounds(100, 100, 419, 309);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();
label.setText("请输入代理服务器地址：");
label.setBounds(21, 21, 151, 18);
getContentPane().add(label);

tf_proxyAddress = new JTextField();
tf_proxyAddress.setBounds(167, 19, 218, 22);
getContentPane().add(tf_proxyAddress);

final JLabel label_1 = new JLabel();
label_1.setText("输入要访问的网站网址，然后回车");
label_1.setBounds(21, 45, 218, 18);
getContentPane().add(label_1);

tf_accessAddress = new JTextField();
tf_accessAddress.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
String proxyAddress = tf_proxyAddress.getText().trim();// 代理服务器地址
setProxyInfo(proxyAddress);// 设置本地代理
String accessAddress = tf_accessAddress.getText().trim();// 获得需要访问的网址
useHttpAccess(accessAddress);// 调用方法，进行http访问
removeProxyInfo();// 清除本地代理
} catch (Exception ex) {

}
}
});
tf_accessAddress.setBounds(21, 69, 364, 22);
getContentPane().add(tf_accessAddress);

final JLabel label_2 = new JLabel();
label_2.setText("访问结果");
label_2.setBounds(21, 97, 75, 18);
getContentPane().add(label_2);

final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(21, 121, 358, 140);
getContentPane().add(scrollPane);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);
//
}

18.3 TCP实用程序
实例520 聊天室服务器端
private JTextArea ta_info;
private ServerSocket server; // 声明ServerSocket对象
private Socket socket; // 声明Socket对象socket
private Hashtable<String, Socket> map = new Hashtable<String, Socket>();// 用于存储连接到服务器的用户和客户端套接字对象

public void createSocket() {
try {
server = new ServerSocket(1982);// 创建服务器套接字对象
while (true) {
ta_info.append("等待新客户连接......\n");
socket = server.accept();// 获得套接字对象
ta_info.append("客户端连接成功。" + socket + "\n");
new ServerThread(socket).start();// 创建并启动线程对象
}
} catch (IOException e) {
e.printStackTrace();
}
}

class ServerThread extends Thread {
Socket socket;
public ServerThread(Socket socket) {
this.socket = socket;
}
public void run() {
try {
ObjectInputStream ins = new ObjectInputStream(socket
.getInputStream());
while (true) {
Vector v = null;
try {
v = (Vector) ins.readObject();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
if (v != null && v.size() > 0) {
for (int i = 0; i < v.size(); i++) {
String info = (String) v.get(i);// 读取信息
String key = "";
if (info.startsWith("用户：")) {// 添加登录用户到客户端列表
key = info.substring(3, info.length());// 获得用户名并作为键使用
map.put(key, socket);// 添加键值对
Set<String> set = map.keySet();// 获得集合中所有键的Set视图
Iterator<String> keyIt = set.iterator();// 获得所有键的迭代器
while (keyIt.hasNext()) {
String receiveKey = keyIt.next();// 获得表示接收信息的键
Socket s = map.get(receiveKey);// 获得与该键对应的套接字对象
PrintWriter out = new PrintWriter(s
.getOutputStream(), true);// 创建输出流对象
Iterator<String> keyIt1 = set.iterator();// 获得所有键的迭代器
while (keyIt1.hasNext()) {
String receiveKey1 = keyIt1.next();// 获得键，用于向客户端添加用户列表
out.println(receiveKey1);// 发送信息
out.flush();// 刷新输出缓冲区
}
}
} else if (info.startsWith("退出：")) {
key = info.substring(3);// 获得退出用户的键
map.remove(key);// 添加键值对
Set<String> set = map.keySet();// 获得集合中所有键的Set视图
Iterator<String> keyIt = set.iterator();// 获得所有键的迭代器
while (keyIt.hasNext()) {
String receiveKey = keyIt.next();// 获得表示接收信息的键
Socket s = map.get(receiveKey);// 获得与该键对应的套接字对象
PrintWriter out = new PrintWriter(s
.getOutputStream(), true);// 创建输出流对象
out.println("退出：" + key);// 发送信息
out.flush();// 刷新输出缓冲区
}
} else {// 转发接收的消息
key = info.substring(info.indexOf("：发送给：") + 5,
info.indexOf("：的信息是："));// 获得接收方的key值,即接收方的用户名
String sendUser = info.substring(0, info
.indexOf("：发送给："));// 获得发送方的key值,即发送方的用户名
Set<String> set = map.keySet();// 获得集合中所有键的Set视图
Iterator<String> keyIt = set.iterator();// 获得所有键的迭代器
while (keyIt.hasNext()) {
String receiveKey = keyIt.next();// 获得表示接收信息的键
if (key.equals(receiveKey) && !sendUser.equals(receiveKey)) {// 与接受用户相同，但不是发送用户
Socket s = map.get(receiveKey);// 获得与该键对应的套接字对象
PrintWriter out = new PrintWriter(s.getOutputStream(), true);// 创建输出流对象
out.println("MSG:" + info);// 发送信息
out.flush();// 刷新输出缓冲区
}
}
}
}
}
}
} catch (IOException e) {
ta_info.append(socket + "已经退出。\n");
}
}
}

public static void main(String args[]) {
ChatServerFrame frame = new ChatServerFrame();
frame.setVisible(true);
frame.createSocket();
}

/**
* Create the frame
*/
public ChatServerFrame() {
super();
addWindowListener(new WindowAdapter() {
public void windowIconified(final WindowEvent e) {
setVisible(false);
}
});
setTitle("聊天室服务器端");
setBounds(100, 100, 385, 266);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_info = new JTextArea();
scrollPane.setViewportView(ta_info);

//托盘
if (SystemTray.isSupported()){                                      // 判断是否支持系统托盘
URL url=ChatServerFrame.class.getResource("server.png");          // 获取图片所在的URL
ImageIcon icon = new ImageIcon(url);                            // 实例化图像对象
Image image=icon.getImage();                                    // 获得Image对象
TrayIcon trayIcon=new TrayIcon(image);                          // 创建托盘图标
trayIcon.addMouseListener(new MouseAdapter(){                   // 为托盘添加鼠标适配器
public void mouseClicked(MouseEvent e){                     // 鼠标事件
if (e.getClickCount()==2){                              // 判断是否双击了鼠标
showFrame();                                    // 调用方法显示窗体
}
}
});
trayIcon.setToolTip("系统托盘");                                    // 添加工具提示文本
PopupMenu popupMenu=new PopupMenu();                    // 创建弹出菜单
MenuItem exit=new MenuItem("退出");                           // 创建菜单项
exit.addActionListener(new ActionListener() {                   // 添加事件监听器
public void actionPerformed(final ActionEvent arg0) {
System.exit(0);                                     // 退出系统
}
});
popupMenu.add(exit);                                        // 为弹出菜单添加菜单项
trayIcon.setPopupMenu(popupMenu);                           // 为托盘图标加弹出菜弹
SystemTray systemTray=SystemTray.getSystemTray();           // 获得系统托盘对象
try{
systemTray.add(trayIcon);                               // 为系统托盘加托盘图标
}catch(Exception e){
e.printStackTrace();
}
}
}
public void showFrame(){
this.setVisible(true);                                              // 显示窗体
this.setState(Frame.NORMAL);
}

实例521 聊天室客户端
private JTextField tf_newUser;
private JList user_list;
private JTextArea ta_info;
private JTextField tf_send;
private ObjectOutputStream out;// 声明输出流对象
private boolean loginFlag = false;// 为true时表示已经登录，为false时表示未登录

public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ChatClientFrame frame = new ChatClientFrame();
frame.setVisible(true);
frame.createClientSocket();// 调用方法创建套接字对象
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

public void createClientSocket() {
try {
Socket socket = new Socket("192.168.1.193", 1982);// 创建套接字对象
out = new ObjectOutputStream(socket.getOutputStream());// 创建输出流对象
new ClientThread(socket).start();// 创建并启动线程对象
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

class ClientThread extends Thread {
Socket socket;
public ClientThread(Socket socket) {
this.socket = socket;
}
public void run() {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));// 创建输入流对象
DefaultComboBoxModel model = (DefaultComboBoxModel) user_list
.getModel();// 获得列表框的模型
while (true) {
String info = in.readLine().trim();// 读取信息
if (!info.startsWith("MSG:")) {// 接收到的不是消息
if (info.startsWith("退出：")) {// 接收到的是退出消息
model.removeElement(info.substring(3));// 从用户列表中移除用户
} else {// 接收到的是登录用户
boolean itemFlag = false;// 标记是否为列表框添加列表项，为true不添加，为false添加
for (int i = 0; i < model.getSize(); i++) {// 对用户列表进行遍历
if (info.equals((String) model.getElementAt(i))) {// 如果用户列表中存在该用户名
itemFlag = true;// 设置为true，表示不添加到用户列表
break;// 结束for循环
}
}
if (!itemFlag) {
model.addElement(info);// 将登录用户添加到用户列表
}
}
} else {// 如果获得的是消息，则在文本域中显示接收到的消息
DateFormat df = DateFormat.getDateInstance();// 获得DateFormat实例
String dateString = df.format(new Date());         // 格式化为日期
df = DateFormat.getTimeInstance(DateFormat.MEDIUM);// 获得DateFormat实例
String timeString = df.format(new Date());         // 格式化为时间
String sendUser = info.substring(4,info.indexOf("：发送给："));// 获得发送信息的用户
String receiveInfo = info.substring(info.indexOf("：的信息是：")+6);// 获得接收到的信息
ta_info.append(" "+sendUser + "    " +dateString+" "+timeString+"\n "+receiveInfo+"\n");// 在文本域中显示信息
ta_info.setSelectionStart(ta_info.getText().length()-1);// 设置选择起始位置
ta_info.setSelectionEnd(ta_info.getText().length());// 设置选择的结束位置
tf_send.requestFocus();// 使发送信息文本框获得焦点
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

private void send() {
if (!loginFlag) {
JOptionPane.showMessageDialog(null, "请先登录。");
return;// 如果用户没登录则返回
}
String sendUserName = tf_newUser.getText().trim();// 获得登录用户名
String info = tf_send.getText();// 获得输入的发送信息
if (info.equals("")) {
return;// 如果没输入信息则返回，即不发送
}
Vector<String> v = new Vector<String>();// 创建向量对象，用于存储发送的消息
Object[] receiveUserNames = user_list.getSelectedValues();// 获得选择的用户数组
if (receiveUserNames.length <= 0) {
return;// 如果没选择用户则返回
}
for (int i = 0; i < receiveUserNames.length; i++) {
String msg = sendUserName + "：发送给：" + (String) receiveUserNames[i]
+ "：的信息是： " + info;// 定义发送的信息
v.add(msg);// 将信息添加到向量
}
try {
out.writeObject(v);// 将向量写入输出流，完成信息的发送
out.flush();// 刷新输出缓冲区
} catch (IOException e) {
e.printStackTrace();
}
DateFormat df = DateFormat.getDateInstance();// 获得DateFormat实例
String dateString = df.format(new Date());         // 格式化为日期
df = DateFormat.getTimeInstance(DateFormat.MEDIUM);// 获得DateFormat实例
String timeString = df.format(new Date());         // 格式化为时间
String sendUser = tf_newUser.getText().trim();// 获得发送信息的用户
String receiveInfo = tf_send.getText().trim();// 显示发送的信息
ta_info.append(" "+sendUser + "    " +dateString+" "+timeString+"\n "+receiveInfo+"\n");// 在文本域中显示信息
tf_send.setText(null);// 清空文本框
ta_info.setSelectionStart(ta_info.getText().length()-1);// 设置选择的起始位置
ta_info.setSelectionEnd(ta_info.getText().length());// 设置选择的结束位置
tf_send.requestFocus();// 使发送信息文本框获得焦点
}

/**
* Create the frame
*/
public ChatClientFrame() {
super();
setTitle("聊天室客户端");
setBounds(100, 100, 385, 288);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);

final JLabel label = new JLabel();
label.setText("输入聊天内容：");
panel.add(label);

tf_send = new JTextField();
tf_send.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
send();// 调用方法发送信息
}
});
tf_send.setPreferredSize(new Dimension(180, 25));
panel.add(tf_send);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
send();// 调用方法发送信息
}
});
button.setText("发送");
panel.add(button);

final JSplitPane splitPane = new JSplitPane();
splitPane.setDividerLocation(100);
getContentPane().add(splitPane, BorderLayout.CENTER);

final JScrollPane scrollPane = new JScrollPane();
splitPane.setRightComponent(scrollPane);

ta_info = new JTextArea();
ta_info.setFont(new Font("", Font.BOLD, 14));
scrollPane.setViewportView(ta_info);

final JScrollPane scrollPane_1 = new JScrollPane();
splitPane.setLeftComponent(scrollPane_1);

user_list = new JList();
user_list.setModel(new DefaultComboBoxModel(new String[] { "" }));
scrollPane_1.setViewportView(user_list);

final JPanel panel_1 = new JPanel();
getContentPane().add(panel_1, BorderLayout.NORTH);

final JLabel label_1 = new JLabel();
label_1.setText("用户名称：");
panel_1.add(label_1);

tf_newUser = new JTextField();
tf_newUser.setPreferredSize(new Dimension(140, 25));
panel_1.add(tf_newUser);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
if (loginFlag) {// 已登录标记为true
JOptionPane.showMessageDialog(null, "在同一窗口只能登录一次。");
return;
}
String userName = tf_newUser.getText().trim();// 获得登录用户名
Vector v = new Vector();// 定义向量，用于存储登录用户
v.add("用户：" + userName);// 添加登录用户
try {
out.writeObject(v);// 将用户向量发送到服务器
out.flush();// 刷新输出缓冲区
} catch (IOException ex) {
ex.printStackTrace();
}
tf_newUser.setEnabled(false);// 禁用用户文本框
loginFlag = true;// 将已登录标记设置为true
}
});
button_1.setText("登录");
panel_1.add(button_1);

final JButton button_2 = new JButton();
button_2.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
String exitUser = tf_newUser.getText().trim();
Vector v = new Vector();
v.add("退出：" + exitUser);
try {
out.writeObject(v);
out.flush();// 刷新输出缓冲区
} catch (IOException ex) {
ex.printStackTrace();
}
System.exit(0);                                     // 退出系统
}
});
button_2.setText("退出");
panel_1.add(button_2);
//托盘
if (SystemTray.isSupported()){                                      // 判断是否支持系统托盘
URL url=ChatClientFrame.class.getResource("client.png");          // 获取图片所在的URL
ImageIcon icon = new ImageIcon(url);                            // 实例化图像对象
Image image=icon.getImage();                                    // 获得Image对象
TrayIcon trayIcon=new TrayIcon(image);                          // 创建托盘图标
trayIcon.addMouseListener(new MouseAdapter(){                   // 为托盘添加鼠标适配器
public void mouseClicked(MouseEvent e){                     // 鼠标事件
if (e.getClickCount()==2){                              // 判断是否双击了鼠标
showFrame();                                    // 调用方法显示窗体
}
}
});
trayIcon.setToolTip("系统托盘");                                    // 添加工具提示文本
PopupMenu popupMenu=new PopupMenu();                    // 创建弹出菜单
MenuItem exit=new MenuItem("退出");                           // 创建菜单项
exit.addActionListener(new ActionListener() {                   // 添加事件监听器
public void actionPerformed(final ActionEvent arg0) {
String exitUser = tf_newUser.getText().trim();
Vector v = new Vector();
v.add("退出：" + exitUser);
try {
out.writeObject(v);
out.flush();// 刷新输出缓冲区
} catch (IOException ex) {
ex.printStackTrace();
}
System.exit(0);                                     // 退出系统
}
});
popupMenu.add(exit);                                        // 为弹出菜单添加菜单项
trayIcon.setPopupMenu(popupMenu);                           // 为托盘图标加弹出菜弹
SystemTray systemTray=SystemTray.getSystemTray();           // 获得系统托盘对象
try{
systemTray.add(trayIcon);                               // 为系统托盘加托盘图标
}catch(Exception e){
e.printStackTrace();
}
}

}
public void showFrame(){
this.setVisible(true); // 显示窗体
this.setState(Frame.NORMAL);
}

第19章邮件收发
19.1 简单邮件
实例522 配置邮件服务
实例523 发送邮件
private JTextArea ta_text;
private JTextField tf_title;
private JTextField tf_send;
private JTextField tf_receive;
private Session session;// 定义Session对象
private String sendHost = "localhost";// 定义发送邮件的主机
private String sendProtocol="smtp";// 定义使用的发送协议
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
SendMailFrame frame = new SendMailFrame();
frame.init();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public SendMailFrame() {
super();
setTitle("发送邮件窗体");
getContentPane().setLayout(null);
setBounds(100, 100, 439, 299);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 22));
label.setText("发送电子邮件");
label.setBounds(144, 10, 185, 24);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("收件人地址：");
label_1.setBounds(22, 42, 85, 18);
getContentPane().add(label_1);

tf_receive = new JTextField();
tf_receive.setBounds(113, 40, 287, 22);
getContentPane().add(tf_receive);

final JLabel label_2 = new JLabel();
label_2.setText("发件人地址：");
label_2.setBounds(22, 68, 78, 18);
getContentPane().add(label_2);

tf_send = new JTextField();
tf_send.setBounds(113, 66, 287, 22);
getContentPane().add(tf_send);

final JLabel label_3 = new JLabel();
label_3.setText("主题：");
label_3.setBounds(32, 92, 66, 18);
getContentPane().add(label_3);

tf_title = new JTextField();
tf_title.setBounds(113, 94, 287, 22);
getContentPane().add(tf_title);

final JLabel label_4 = new JLabel();
label_4.setText("正文：");
label_4.setBounds(34, 128, 66, 18);
getContentPane().add(label_4);

final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(113, 128, 287, 91);
getContentPane().add(scrollPane);

ta_text = new JTextArea();
scrollPane.setViewportView(ta_text);

final JButton btn_send = new JButton();
btn_send.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
String fromAddr = tf_send.getText().trim();
String toAddr = tf_receive.getText().trim();// 真实存在的目标邮件地址
String title = tf_title.getText().trim();
String text = ta_text.getText().trim();
try {
sendMessage(fromAddr, toAddr, title, text);
} catch (Exception e1) {
e1.printStackTrace();
}
}
});
btn_send.setText("发送");
btn_send.setBounds(144, 225, 78, 28);
getContentPane().add(btn_send);

final JButton btn_exit = new JButton();
btn_exit.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
System.exit(0);
}
});
btn_exit.setText("退出");
btn_exit.setBounds(279, 225, 78, 28);
getContentPane().add(btn_exit);
}
public void init() throws Exception {
Properties props = new Properties();// 创建属性对象
props.put("mail.transport.protocol", sendProtocol);// 指定邮件传输协议
props.put("mail.smtp.class", "com.sun.mail.smtp.SMTPTransport");//指定传输协议使用的类
props.put("mail.smtp.host", sendHost);// 定义发送邮件的主机
session = Session.getDefaultInstance(props);// 创建Session对象
}
/**
* @param fromAddr 发送者
* @param toAddr 接收者
* @param title 主题
* @param text 内容
* @throws Exception 异常
*/
public void sendMessage(String fromAddr,String toAddr,String title,String text) throws Exception {
Message msg = new MimeMessage(session);// 创建Message对象
InternetAddress[] toAddrs = InternetAddress.parse(toAddr,false);// 创建接收方的InternetAddress对象
msg.setRecipients(Message.RecipientType.TO, toAddrs);// 指定接收方
msg.setSentDate(new Date());// 指定接发送日期
msg.setSubject(title);// 设置主题
msg.setFrom(new InternetAddress(fromAddr));// 指定发送者
msg.setText(text);// 指定发送内容
Transport.send(msg);// 发送邮件
JOptionPane.showMessageDialog(null, "邮件发送成功。");
}

实例524 接收邮件
private JTextArea ta_receive;
protected Session session;
protected Store store;
private String receiveHost = "localhost";// 接收主机
private String receiveProtocol = "imap";// 接收协议
private String username = "zzk";// 用户名
private String password = "zzk";// 密码
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ReceiveMailFrame frame = new ReceiveMailFrame();
frame.init();// 调用初始化方法
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

public ReceiveMailFrame() {
super();
getContentPane().setLayout(new BorderLayout());
setTitle("接收邮件窗体");
setBounds(100, 100, 386, 314);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_receive = new JTextArea();
scrollPane.setViewportView(ta_receive);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
receiveMessage();// 调用接收信息的方法
} catch (Exception e1) {
e1.printStackTrace();
}
}
});
button.setText("接收邮件");
panel.add(button);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
System.exit(0);
}
});
button_1.setText("退出系统");
panel.add(button_1);
}
public void init() throws Exception {
Properties props = new Properties();// 声明Properties对象
props.put("mail.store.protocol", receiveProtocol);// 指定接收协议
props.put("mail.imap.class", "com.sun.mail.imap.IMAPStore");// 指定使用Store进行接收
session = Session.getDefaultInstance(props);// 获得Session对象
store = session.getStore(receiveProtocol);// 获得Store对象
store.connect(receiveHost,username,password);// 连接接收服务器
}
public void receiveMessage() throws Exception {
Folder folder = store.getFolder("inbox");// 获得inbox邮件夹的Folder对象
if (folder == null) {
throw new Exception("不存在inbox邮件夹。");
}
folder.open(Folder.READ_ONLY);// 以只读方式打开邮件夹
ta_receive.append("您共收到"+folder.getMessageCount()+"个电子邮件。\n\n");
Message[] messages = folder.getMessages();// 获得邮件夹中的所有邮件
for (int i = 0;i<messages.length;i++){
ta_receive.append("----第"+(i+1)+"个邮件----\n");
ta_receive.append("主题："+folder.getMessage(i+1).getSubject()+"\n");// 主题
ta_receive.append("正文："+folder.getMessage(i+1).getContent()+"\n");// 正文
ta_receive.append("发送日期："+folder.getMessage(i+1).getSentDate()+"\n");// 发送日期
Address[] ias = folder.getMessage(i+1).getFrom();// 发件人地址
ta_receive.append("发件人："+ias[0]+"\n");
Address[] iasTo = folder.getMessage(i+1).getAllRecipients();// 收件人地址
ta_receive.append("收件人："+iasTo[0]+"\n\n");
}
folder.close(false);// 关闭邮件夹，但不删除邮件
store.close();// 关闭Store对象
}

19.2 复杂邮件
实例525 发送带附件的邮件
private JTextArea ta_attachment;
private JTextArea ta_text;
private JTextField tf_title;
private JTextField tf_send;
private JTextField tf_receive;
private Session session;
private String sendHost = "localhost";
private String sendProtocol="smtp";
private String filePathAndName = null;
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
SendAttachmentMailFrame frame = new SendAttachmentMailFrame();
frame.init();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public SendAttachmentMailFrame() {
super();
setTitle("发送带附件的邮件");
getContentPane().setLayout(null);
setBounds(100, 100, 439, 358);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 22));
label.setText("发送带附件的邮件");
label.setBounds(113, 10, 217, 24);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("收件人地址：");
label_1.setBounds(22, 42, 85, 18);
getContentPane().add(label_1);

tf_receive = new JTextField();
tf_receive.setBounds(113, 40, 287, 22);
getContentPane().add(tf_receive);

final JLabel label_2 = new JLabel();
label_2.setText("发件人地址：");
label_2.setBounds(22, 68, 78, 18);
getContentPane().add(label_2);

tf_send = new JTextField();
tf_send.setBounds(113, 66, 287, 22);
getContentPane().add(tf_send);

final JLabel label_3 = new JLabel();
label_3.setText("主题：");
label_3.setBounds(32, 92, 66, 18);
getContentPane().add(label_3);

tf_title = new JTextField();
tf_title.setBounds(113, 94, 287, 22);
getContentPane().add(tf_title);

final JLabel label_4 = new JLabel();
label_4.setText("正文：");
label_4.setBounds(34, 128, 66, 18);
getContentPane().add(label_4);

final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(113, 128, 287, 76);
getContentPane().add(scrollPane);

ta_text = new JTextArea();
scrollPane.setViewportView(ta_text);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
JFileChooser fileChooser = new JFileChooser(); // 创建文件对话框
int returnValue = fileChooser.showOpenDialog(null);// 打开文件选择对话框
if (returnValue == JFileChooser.APPROVE_OPTION) { // 判断是否选择了文件
File file = fileChooser.getSelectedFile(); // 获得文件对象
if (file.length() / 1024.0 / 1024 > 50.0) {
JOptionPane.showMessageDialog(null, "请选择小于等于50MB的文件。");
return;
}
filePathAndName = file.getAbsolutePath();// 获得文件的完整路径和文件名
ta_attachment.append(file.getName());// 显示附件文件的名称
}
}
});
button.setText("添加附件");
button.setBounds(113, 282, 106, 28);
getContentPane().add(button);

final JLabel label_5 = new JLabel();
label_5.setText("附件：");
label_5.setBounds(32, 210, 66, 18);
getContentPane().add(label_5);

final JScrollPane scrollPane_1 = new JScrollPane();
scrollPane_1.setBounds(112, 213, 287, 63);
getContentPane().add(scrollPane_1);

ta_attachment = new JTextArea();
scrollPane_1.setViewportView(ta_attachment);
}
public void init() throws Exception {
Properties props = new Properties();
props.put("mail.transport.protocol", sendProtocol);
props.put("mail.smtp.class", "com.sun.mail.smtp.SMTPTransport");
props.put("mail.smtp.host", sendHost);
session = Session.getDefaultInstance(props);
}
/**
* @param fromAddr 发送方地址
* @param toAddr 接收方地址
* @param title 主题
* @param text 文本内容
* @throws Exception 异常
*/
public void sendMessage(String fromAddr,String toAddr,String title,String text) throws Exception {
Message msg = new MimeMessage(session);// 创建Message对象
InternetAddress[] toAddrs = InternetAddress.parse(toAddr,false);// 接收方地址
msg.setRecipients(Message.RecipientType.TO, toAddrs);// 指定接收方
msg.setSentDate(new Date());// 设置发送日期
msg.setSubject(title);// 设置主题
msg.setFrom(new InternetAddress(fromAddr));// 设置发送地址
Multipart multipart = new MimeMultipart();// 可以添加复杂内容的Multipart对象
MimeBodyPart mimeBodyPartText = new MimeBodyPart();// 添加正文的MimeBodyPart对象
mimeBodyPartText.setText(text);// 指定正文
multipart.addBodyPart(mimeBodyPartText);// 添加到Multipart对象上
if (filePathAndName!=null && !filePathAndName.equals("")){
MimeBodyPart mimeBodyPartAdjunct = new MimeBodyPart();// 添加附件的MimeBodyPart对象
FileDataSource fileDataSource = new FileDataSource(filePathAndName);// 创建附件的FileDataSource对象
mimeBodyPartAdjunct.setDataHandler(new DataHandler(fileDataSource));// 指定数据
mimeBodyPartAdjunct.setDisposition(Part.ATTACHMENT);// 指定添加的内容是附件
String name = fileDataSource.getName();
mimeBodyPartAdjunct.setFileName(MimeUtility.encodeText(name, "GBK", null));// 指定附件文件的名称
multipart.addBodyPart(mimeBodyPartAdjunct);// 添加到Multipart对象上
}
msg.setContent(multipart);// 设置邮件内容
Transport.send(msg);// 发送邮件
filePathAndName = null;
JOptionPane.showMessageDialog(null, "邮件发送成功。");
}

实例526 接收带附件的邮件
private JTextArea ta_receive;
protected Session session;
protected Store store;
private String receiveHost = "localhost";// 接收主机
private String receiveProtocol = "imap";// 接收协议
private String username = "zzk";// 用户名
private String password = "zzk";// 密码

public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ReceiveMailFrame frame = new ReceiveMailFrame();
frame.init();// 调用初始化方法
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

public ReceiveMailFrame() {
super();
getContentPane().setLayout(new BorderLayout());
setTitle("接收邮件窗体");
setBounds(100, 100, 386, 314);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);

ta_receive = new JTextArea();
scrollPane.setViewportView(ta_receive);

final JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.SOUTH);

final JButton button = new JButton();
button.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
try {
receiveMessage();// 调用接收信息的方法
} catch (Exception e1) {
e1.printStackTrace();
}
}
});
button.setText("接收邮件并下载附件");
panel.add(button);

final JButton button_1 = new JButton();
button_1.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
System.exit(0);
}
});
button_1.setText("退出系统");
panel.add(button_1);
}

public void init() throws Exception {
Properties props = new Properties();// 声明Properties对象
props.put("mail.store.protocol", receiveProtocol);// 指定接收协议
props.put("mail.imap.class", "com.sun.mail.imap.IMAPStore");// 指定使用Store进行接收
session = Session.getDefaultInstance(props);// 获得Session对象
store = session.getStore(receiveProtocol);// 获得Store对象
store.connect(receiveHost, username, password);// 连接接收服务器
}

public void receiveMessage() throws Exception {
Folder folder = store.getFolder("inbox");// 获得inbox邮件夹的Folder对象
if (folder == null) {
throw new Exception("不存在inbox邮件夹。");
}
folder.open(Folder.READ_ONLY);// 以只读方式打开邮件夹
ta_receive.append("您共收到" + folder.getMessageCount() + "个电子邮件。\n\n");
Message[] messages = folder.getMessages();// 获得邮件夹中的所有邮件
for (int i = 0; i < messages.length; i++) {
Object content = messages[i].getContent();// 获得邮件内容
if (content instanceof Multipart) {// 有附件执行的代码
ta_receive.append("----第" + (i + 1) + "个邮件----\n");
ta_receive.append("主题：" + folder.getMessage(i + 1).getSubject() + "\n");// 主题
Multipart mPart = (Multipart) content;// 转换为Multipart对象
ta_receive.append("正文：" + mPart.getBodyPart(0).getContent() + "\n");// 正文内容
ta_receive.append("发送日期：" + folder.getMessage(i + 1).getSentDate() + "\n");// 发送日期
Address[] ias = folder.getMessage(i + 1).getFrom();// 发件人地址
ta_receive.append("发件人：" + ias[0] + "\n");
Address[] iasTo = folder.getMessage(i + 1).getAllRecipients();// 收件人地址
ta_receive.append("收件人：" + iasTo[0] + "\n\n");
try {
String fileName = mPart.getBodyPart(1).getFileName();// 获得文件名
ta_receive.append("接收到一个名为“" + MimeUtility.decodeText(fileName) + "”的附件\n");
InputStream in = mPart.getBodyPart(1).getInputStream();
FileDialog dialog = new FileDialog(ReceiveMailFrame.this, "保存");// 创建对话框
dialog.setMode(FileDialog.SAVE);// 设置对话框为保存对话框
dialog.setFile(MimeUtility.decodeText(fileName));
dialog.setVisible(true);// 显示保存对话框
String path = dialog.getDirectory();// 获得文件的保存路径
String saveFileName = dialog.getFile();// 获得保存的文件名
if (path == null || saveFileName == null) {
return;
}
OutputStream out = new BufferedOutputStream(new FileOutputStream(path + "/" + saveFileName));// 创建保存附件文件的输出流对象
int len = -1;
while ((len = in.read()) != -1) {
out.write(len);// 向输出流写入数据
}
out.close();
in.close();
} catch (Exception ex) {
}
} else {// 没有附件执行的代码
ta_receive.append("----第" + (i + 1) + "个邮件----\n");
ta_receive.append("主题：" + folder.getMessage(i + 1).getSubject() + "\n");// 主题
ta_receive.append("正文：" + folder.getMessage(i + 1).getContent() + "\n");// 正文
ta_receive.append("发送日期：" + folder.getMessage(i + 1).getSentDate() + "\n");// 发送日期
Address[] ias = folder.getMessage(i + 1).getFrom();// 发件人地址
ta_receive.append("发件人：" + ias[0] + "\n");
Address[] iasTo = folder.getMessage(i + 1).getAllRecipients();// 收件人地址
ta_receive.append("收件人：" + iasTo[0] + "\n\n");
}
}
folder.close(false);// 关闭邮件夹，但不删除邮件
store.close();// 关闭Store对象
}

public void receiveText(Message message) {

}

实例527 发送邮件时进行身份验证
CheckAuthenticator.java
private JPasswordField pf_pwd;// 密码框
private JTextField tf_user;// 用户名文本框

public UserPassDialog() {
super();
getContentPane().setLayout(null);
setTitle("身份验证对话框");
setBounds(100, 100, 253, 165);

final JLabel label = new JLabel();
label.setText("用户名称：");
label.setBounds(10, 25, 66, 18);
getContentPane().add(label);

tf_user = new JTextField();
tf_user.setBounds(82, 23, 146, 22);
getContentPane().add(tf_user);

final JLabel label_1 = new JLabel();
label_1.setText("用户密码：");
label_1.setBounds(10, 63, 66, 18);
getContentPane().add(label_1);

pf_pwd = new JPasswordField();
pf_pwd.setBounds(82, 61, 146, 22);
getContentPane().add(pf_pwd);

final JButton btn_ok = new JButton();
btn_ok.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setVisible(false);
}
});
btn_ok.setText("确定");
btn_ok.setBounds(20, 89, 92, 28);
getContentPane().add(btn_ok);

final JButton btn_return = new JButton();
btn_return.addActionListener(new ActionListener() {
public void actionPerformed(final ActionEvent e) {
setVisible(false);
}
});
btn_return.setText("返回");
btn_return.setBounds(132, 89, 92, 28);
getContentPane().add(btn_return);
//
}

}

public PasswordAuthentication getPasswordAuthentication() {
UserPassDialog dialog = new UserPassDialog();// 创建对话框
dialog.setModal(true);// 设置为模式对话框
dialog.setVisible(true);// 显示对话框
String user = dialog.tf_user.getText().trim();// 获得用户名
String pwd = new String(dialog.pf_pwd.getPassword());// 获得密码
dialog.tf_user.setText(null);// 清空用户名文本框
dialog.pf_pwd.setText(null);// 清空密码框
return new PasswordAuthentication(user, pwd);// 返回PasswordAuthentication对象
}
SendAttachmentMailFrame.java
private JTextArea ta_attachment;
private JTextArea ta_text;
private JTextField tf_title;
private JTextField tf_send;
private JTextField tf_receive;
private Session session;
private String sendHost = "localhost";
private String sendProtocol="smtp";
private String filePathAndName = null;
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
SendAttachmentMailFrame frame = new SendAttachmentMailFrame();
frame.init();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public SendAttachmentMailFrame() {
super();
setTitle("发送邮件时进行身份验证");
getContentPane().setLayout(null);
setBounds(100, 100, 439, 358);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();
label.setForeground(new Color(0, 0, 255));
label.setFont(new Font("", Font.BOLD, 22));
label.setText("发送邮件时进行身份验证");
label.setBounds(70, 10, 274, 24);
getContentPane().add(label);