java通信技术（java通讯系统）
华为云服务器特价优惠火热进行中！ 2核2G2兆仅需 38 元；4核4G3兆仅需 79 元。购买时间越长越优惠！更多配置及优惠价格请咨询客服。
合作流程： |
本篇文章给大家谈谈java通信技术，以及java通讯系统对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
微信号：cloud7591如需了解更多，欢迎添加客服微信咨询。
复制微信号
本文目录一览：
- 1、IT技术与java技术有什么区别？
- 2、通信系统都用到java里的什么技术啊？
- 3、java如何实现进程间的通信
- 4、Java Socket通信技术收发线程互斥的解决方法
- 5、java开发聊天功能用什么技术实现的？
IT技术与java技术有什么区别？
信息技术（Information
Technology，简称IT），是主要用于管理和处理信息所采用的各种技术的总称。它主要是应用计算机科学和通信技术来设计、开发、安装和实施信息系统及应用软件。它也常被称为信息和通信技术（Information
and
Communications
Technology,
ICT）。主要包括传感技术、计算机技术和通信技术。
Java技术是一种高级的面向对象的编程语言，也是一个平台。java技术基于java虚拟机（JVM是语言与底层软件和硬件之间的一种转换器）。java语言的所有实现都必须基于虚拟机。从而使用java编写的程序可以运行在有JVM的任何系统上，实现真正的跨平台。
IT更像一个大范围的领域，而Java就好比是其中的某个领域的实现手段。
通信系统都用到java里的什么技术啊？
通信主要是java的Socket编程
网络编程主要类和接口:
java.net.Socket 此类实现客户端套接字,一般客户端都是该类的对象。该类的构造函数很多，如可以指定服务器端的IP和端口号
java.net.ServerSocket 此类实现服务器套接字，在构造函数中指定端口.
通信大概的步骤:
服务器端
1.服务器绑定端口，可以在构造函数中指定，或者 调用bind()方法
2.监听客户端请求 accept()方法，返回一个Socket对象
3.获得输入流 使用Socket的getInputStream()返回客户端的发送过来的的信息
4.获得输出流 使用Socket的getOutputStream()，获得输出流然后将要返回给客户端的内容加到输出流中
5.发送信息 flush()方法
6. 继续监听 或则 是关闭Socket 使用close()方法
客户端
1.指定服务器IP和端口进行连接 可以使用构造函数 或则 是connect()方法
2.获得输出流 使用Socket的getOutputStream()，获得输出流然后将要返回给客户端的内容加到输出流中
3.发送信息 flush()方法
4.获得输入流 使用Socket的getInputStream()返回客户端的发送过来的的信息 即服务器端的信息
5.关闭Socket 使用close()方法
如果是串口 或则是并口通信的话 不是J2SE的内容，不过有开源组织实现相关的接口.如JUsb 等等
java如何实现进程间的通信
传统的进程间通信的方式有大致如下几种：
(1) 管道(PIPE)
(2) 命名管道(FIFO)
(3) 信号量(Semphore)
(4) 消息队列(MessageQueue)
(5) 共享内存(SharedMemory)
(6) Socket
Java如何支持进程间通信。我们把Java进程理解为JVM进程。很明显，传统的这些大部分技术是无法被我们的应用程序利用了（这些进程间通信都是靠系统调用来实现的）。但是Java也有很多方法可以进行进程间通信的。
除了上面提到的Socket之外，当然首选的IPC可以使用Rmi，或者Corba也可以。另外Java nio的MappedByteBuffer也可以通过内存映射文件来实现进程间通信(共享内存)。
Java Socket通信技术收发线程互斥的解决方法
Java Socket通信技术在很长的时间里都在使用 在不少的程序员眼中都有很多高的评价 那么下面我们就看看如何才能掌握这门复杂的编程语言 希望大家在今后的Java Socket通信技术使用中有所收获
下面就是Java Socket通信技术在解决收发线程互斥的代码介绍
package bill svr;
import java io IOException;
import java io InputStream;
import java io OutputStream;
import InetSocketAddress;
import Socket;
import SocketException;
import SocketTimeoutException;
import java text SimpleDateFormat;
import java util Date;
import java util Properties;
import java util Timer;
import java util TimerTask;
import ncurrent ConcurrentHashMap;
import ncurrent TimeUnit;
import ncurrent locks Condition;
import ncurrent locks ReentrantLock;
import apache log j Logger;
/**
*ptitle: socket通信包装类/p
*pDescription: /p
*pCopyRight: CopyRight (c) /p
*pCompany: /p
*pCreate date: /P
*author sunnylocusA mailto:
/A * v 初类
* v 对命令收发逻辑及收发线程互斥机制进行了优化
处理命令速度由原来 ~ 个/秒提高到 ~ 个/秒
*/ public class SocketConnection {
private volatile Socket socket;
private int timeout = * ; //超时时间 初始值 秒
private boolean isLaunchHeartcheck = false;//是否已启动心跳检测
private boolean isNeorkConnect = false; //网络是否已连接
private static String host = ;
private static int port;
static InputStream inStream = null;
static OutputStream outStream = null;
private static Logger log =Logger getLogger
(SocketConnection class);
private static SocketConnection socketConnection = null;
private static java util Timer heartTimer=null;
//private final MapString Object recMsgMap= Collections
synchronizedMap(new HashMapString Object());
private final ConcurrentHashMapString Object recMsgMap
= new ConcurrentHashMapString Object();
private static Thread receiveThread = null;
private final ReentrantLock lock = new ReentrantLock();
private SocketConnection(){
Properties conf = new Properties();
try {
nf load(SocketConnection class getResourceAsStream
( nf ));
this timeout = Integer valueOf(conf getProperty( timeout ));
init(conf getProperty( ip ) Integer valueOf
(conf getProperty( port )));
} catch(IOException e) {
log fatal( socket初始化异常! e);
throw new RuntimeException( socket初始化异常 请检查配置参数 );
}
}
/**
* 单态模式
*/
public static SocketConnection getInstance() {
if(socketConnection==null) {
synchronized(SocketConnection class) {
if(socketConnection==null) {
socketConnection = new SocketConnection();
return socketConnection;
}
}
}
return socketConnection;
}
private void init(String host int port) throws IOException {
InetSocketAddress addr = new InetSocketAddress(host port);
socket = new Socket();
synchronized (this) {
( 【准备与 +addr+ 建立连接】 );
nnect(addr timeout);
( 【与 +addr+ 连接已建立】 );
inStream = socket getInputStream();
outStream = socket getOutputStream();
socket setTcpNoDelay(true);//数据不作缓冲 立即发送
socket setSoLinger(true );//socket关闭时 立即释放资源
socket setKeepAlive(true);
socket setTrafficClass( x | x );//高可靠性和最小延迟传输
isNeorkConnect=true;
receiveThread = new Thread(new ReceiveWorker());
receiveThread start();
SocketConnection host=host;
SocketConnection port=port;
if(!isLaunchHeartcheck)
launchHeartcheck();
}
}
/**
* 心跳包检测
*/
private void launchHeartcheck() {
if(socket == null)
throw new IllegalStateException( socket is not
established! );
heartTimer = new Timer();
isLaunchHeartcheck = true;
heartTimer schedule(new TimerTask() {
public void run() {
String msgStreamNo = StreamNoGenerator getStreamNo( kq );
int mstType = ;// 心跳包请求
SimpleDateFormat dateformate = new SimpleDateFormat
( yyyyMMddHHmmss );
String msgDateTime = dateformate format(new Date());
int msgLength = ;//消息头长度
String mandstr = +msgLength + mstType + msgStreamNo;
( 心跳检测包 IVR +mandstr);
int reconnCounter = ;
while(true) {
String responseMsg =null;
try {
responseMsg = readReqMsg(mandstr);
} catch (IOException e) {
log error( IO流异常 e);
reconnCounter ++;
}
if(responseMsg!=null) {
( 心跳响应包 IVR +responseMsg);
reconnCounter = ;
break;
} else {
reconnCounter ++;
}
if(reconnCounter ) {//重连次数已达三次 判定网络连接中断
重新建立连接 连接未被建立时不释放锁
reConnectToCTCC(); break;
}
}
}
} * * * * );
}
/**
* 重连与目标IP建立重连
*/
private void reConnectToCTCC() {
new Thread(new Runnable(){
public void run(){
( 重新建立与 +host+ : +port+ 的连接 );
//清理工作 中断计时器 中断接收线程 恢复初始变量
heartTimer cancel();
isLaunchHeartcheck=false;
isNeorkConnect = false;
receiveThread interrupt();
try {
socket close();
} catch (IOException e ) {log error( 重连时 关闭socket连
接发生IO流异常 e );}
//
synchronized(this){
for(; ;){
try {
Thread currentThread();
Thread sleep( * );
init(host port);
this notifyAll();
break ;
} catch (IOException e) {
log error( 重新建立连接未成功 e);
} catch (InterruptedException e){
log error( 重连线程中断 e);
}
}
}
}
}) start();
}
/**
* 发送命令并接受响应
* @param requestMsg
* @return
* @throws SocketTimeoutException
* @throws IOException
*/
public String readReqMsg(String requestMsg) throws IOException {
if(requestMsg ==null) {
return null;
}
if(!isNeorkConnect) {
synchronized(this){
try {
this wait( * ); //等待 秒 如果网络还没有恢复 抛出IO流异常
if(!isNeorkConnect) {
throw new IOException( 网络连接中断！ );
}
} catch (InterruptedException e) {
log error( 发送线程中断 e);
}
}
}
String msgNo = requestMsg substring( + );//读取流水号
outStream = socket getOutputStream();
outStream write(requestMsg getBytes());
outStream flush();
Condition msglock = lock newCondition(); //消息锁
//注册等待接收消息
recMsgMap put(msgNo msglock);
try {
lock lock();
msglock await(timeout TimeUnit MILLISECONDS);
} catch (InterruptedException e) {
log error( 发送线程中断 e);
} finally {
lock unlock();
}
Object respMsg = recMsgMap remove(msgNo); //响应信息
if(respMsg!=null (respMsg != msglock)) {
//已经接收到消息 注销等待 成功返回消息
return (String) respMsg;
} else {
log error(msgNo+ 超时 未收到响应消息 );
throw new SocketTimeoutException(msgNo+ 超时 未收到响应消息 );
}
}
public void finalize() {
if (socket != null) {
try {
socket close();
} catch (IOException e) {
e printStackTrace();
}
}
}
//消息接收线程
private class ReceiveWorker implements Runnable {
String intStr= null;
public void run() {
while(!Thread interrupted()){
try {
byte[] headBytes = new byte[ ];
if(inStream read(headBytes)== ){
log warn( 读到流未尾 对方已关闭流! );
reConnectToCTCC();//读到流未尾 对方已关闭流
return;
}
byte[] tmp =new byte[ ];
tmp = headBytes;
String tempStr = new String(tmp) trim();
if(tempStr==null || tempStr equals( )) {
log error( received message is null );
ntinue;
}
intStr = new String(tmp);
int totalLength =Integer parseInt(intStr);
//
byte[] msgBytes = new byte[totalLength ];
inStream read(msgBytes);
String resultMsg = new String(headBytes)+ new
String(msgBytes);
//抽出消息ID
String msgNo = resultMsg substring( + );
Condition msglock =(Condition) recMsgMap get(msgNo);
if(msglock ==null) {
log warn(msgNo+ 序号可能已被注销！响应消息丢弃 );
recMsgMap remove(msgNo);
ntinue;
}
recMsgMap put(msgNo resultMsg);
try{
lock lock();
msglock signalAll();
}finally {
lock unlock();
}
}catch(SocketException e){
log error( 服务端关闭socket e);
reConnectToCTCC();
} catch(IOException e) {
log error( 接收线程读取响应数据时发生IO流异常 e);
} catch(NumberFormatException e){
log error( 收到没良心包 String转int异常 异常字符: +intStr);
}
}
}
}
}
lishixinzhi/Article/program/Java/hx/201311/25550
java开发聊天功能用什么技术实现的？
实现聊天功能的技术可以有多种选择，以下是其中的一些常用技术：
WebSocket：WebSocket 是一种在 Web 应用程序中提供双向通信的技术，可以实现实时的聊天功能。Java 中可以使用开源的 WebSocket 实现库，如 Tyrus、Netty、Jetty 等。
Socket：Socket 是传统的套接字通信技术，通过建立 TCP 连接来实现客户端和服务器之间的通信。Java 中可以使用 Socket API 来实现聊天功能。
Comet：Comet 是一种通过长轮询（Long Polling）或者流（Streaming）技术实现实时聊天功能的技术。Java 中可以使用 CometD 或者 Atmosphere 等开源库来实现 Comet 技术。
HTTP 轮询：通过不断地向服务器发送请求，来获取聊天消息的变化。Java 中可以使用 Ajax 技术来实现轮询。
无论选择哪种技术，都需要考虑服务器的并发处理能力，以及聊天消息的存储和管理等问题。同时，为了保证聊天数据的安全性，需要使用加密技术来确保聊天消息在传输过程中不被窃听或篡改。
java通信技术的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java通讯系统、java通信技术的信息别忘了在本站进行查找喔。
