这里比较复杂的莫过于spring的配置了那就先上配置applicationContext.xml
mina的配置在最下面
<spring -- mina >这个 之上的 配置有velocity和memcache还有springjdbc，自动装配，json对象支持（注解@ResponseBody）, 切面事务管理 ， 当然这些大家能用的上的 拿走 用不上删掉（跟没说一样）
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<context:property-placeholder location="classpath:jdbc.properties" />
<bean id="stringConverter" class="org.springframework.http.converter.StringHttpMessageConverter">
<property name="supportedMediaTypes">
<list>
<value>text/plain;charset=UTF-8</value>
</list>
</property>
</bean>
<bean id="exceptionResolver" class="com.util.ExceptionHandler"/>
<!-- 输出对象转JSON支持 -->
<bean id="jsonConverter"
class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
<bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="messageConverters">
<list>
<ref bean="stringConverter"/>
<ref bean="jsonConverter" />
</list>
</property>
</bean>
<!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
<!-- <context:component-scan base-package="com.controller" />
<context:component-scan base-package="com.service" />
<context:component-scan base-package="com.dao" /> -->
<context:component-scan base-package="com" />
<!-- 配置数据源 destroy-method="close"-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
<property name="driverClass">
<value>${jdbc.driverClassName}</value>
</property>
<property name="jdbcUrl">
<value>${jdbc.url}</value>
</property>
<property name="user">
<value>${jdbc.username}</value>
</property>
<property name="password">
<value>${jdbc.password}</value>
</property>
<!--连接池中保留的最小连接数。 -->
<property name="minPoolSize">
<value>5</value>
</property>
<!--连接池中保留的最大连接数。Default: 15 -->
<property name="maxPoolSize">
<value>30</value>
</property>
<!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
<property name="initialPoolSize">
<value>10</value>
</property>
<!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
<property name="maxIdleTime">
<value>60</value>
</property>
<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
<property name="acquireIncrement">
<value>5</value>
</property>
<!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements 属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0 -->
<property name="maxStatements">
<value>0</value>
</property>
<!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
<property name="idleConnectionTestPeriod">
<value>60</value>
</property>
<!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
<property name="acquireRetryAttempts">
<value>30</value>
</property>
<!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效 保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
获取连接失败后该数据源将申明已断开并永久关闭。Default: false -->
<property name="breakAfterAcquireFailure">
<value>true</value>
</property>
<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。Default: false -->
<property name="testConnectionOnCheckout">
<value>false</value>
</property>
<property name="automaticTestTable">
<value>true</value>
</property>
</bean>
<!-- 配置Jdbc模板 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="dataSource" />
<!-- 通过AOP配置提供事务增强，让controller包下所有Bean的所有方法拥有事务 -->
<!-- <aop:config proxy-target-class="true">
<aop:pointcut id="serviceMethod"
expression=" execution(* com.controller..*(..))" />
<aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
</aop:config>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*" />
</tx:attributes>
</tx:advice> -->
<!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 -->
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
<!-- VM视图解析器 -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.velocity.VelocityViewResolver">
<property name="requestContextAttribute" value="rc"></property>
<property name="cache" value="true"/>
<property name="prefix" value=""/>
<property name="suffix" value=".vm"/>
<property name="contentType"><value>text/html;charset=UTF-8</value></property>
<property name="dateToolAttribute"><value>dateTool</value></property>
<property name="numberToolAttribute"><value>numberTool</value></property>
</bean>
<!-- 指定模板视图存放位置，以及编码格式 -->
<bean id="velocityConfigurer" class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
<property name="resourceLoaderPath" value="/WEB-INF/velo/"/>
<property name= "velocityProperties">
<props>
<prop key="input.encoding">utf-8</prop>
<prop key="output.encoding">utf-8</prop>
</props>
</property>
</bean>
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>
<!-- 访问数据库前，查询MEMCACHED缓存服务器 -->
<!-- <bean id="memcachedInterceptor" class="com.interceptor.MemcachedInterceptor"></bean>
<aop:config>
<aop:pointcut expression="execution(* select*(..))"
id="memcachedPointCut"/>
<aop:aspect id="memcachedAspect" ref="memcachedInterceptor">
<aop:around pointcut-ref="memcachedPointCut" method="aronud"/>
</aop:aspect>
</aop:config> -->
<!-- 官方文档地址 http://code.google.com/p/xmemcached/wiki/Spring_Integration -->
<bean
id="memcachedClientBuilder"
class="net.rubyeye.xmemcached.XMemcachedClientBuilder"
p:connectionPoolSize="20"
p:failureMode="true">
<constructor-arg>
<list>
<bean class="java.net.InetSocketAddress">
<constructor-arg>
<value>你的memcache的地址</value>
</constructor-arg>
<constructor-arg>
<value>11211</value>
</constructor-arg>
</bean>
<!-- <bean class="java.net.InetSocketAddress"> -->
<!-- <constructor-arg> -->
<!-- <value>192.168.1.2</value> -->
<!-- </constructor-arg> -->
<!-- <constructor-arg> -->
<!-- <value>10002</value> -->
<!-- </constructor-arg> -->
<!-- </bean> -->
<!-- <bean class="java.net.InetSocketAddress"> -->
<!-- <constructor-arg> -->
<!-- <value>192.168.1.3</value> -->
<!-- </constructor-arg> -->
<!-- <constructor-arg> -->
<!-- <value>10003</value> -->
<!-- </constructor-arg> -->
<!-- </bean> -->
<!-- <bean class="java.net.InetSocketAddress"> -->
<!-- <constructor-arg> -->
<!-- <value>192.168.1.4</value> -->
<!-- </constructor-arg> -->
<!-- <constructor-arg> -->
<!-- <value>4</value> -->
<!-- </constructor-arg> -->
<!-- </bean> -->
</list>
</constructor-arg>
<constructor-arg>
<list>
<value>1</value>
<!-- <value>2</value> -->
<!-- <value>3</value> -->
<!-- <value>4</value> -->
</list>
</constructor-arg>
<property name="commandFactory">
<bean class="net.rubyeye.xmemcached.command.TextCommandFactory" />
</property>
<property name="sessionLocator">
<bean class="net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator" />
</property>
<property name="transcoder">
<bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder" />
</property>
</bean>
<bean
id="memcachedClient"
factory-bean="memcachedClientBuilder"
factory-method="build"
destroy-method="shutdown" />
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver"
p:defaultEncoding="utf-8"/>
<mvc:interceptors>
<!-- 拦截所有请求
<bean class="com.etoak.util.LoginCheck2"></bean>-->
<mvc:interceptor>
<mvc:mapping path="/dashboard"/>
<mvc:mapping path="/dashboard/**"/>
<mvc:mapping path="/setting"/>
<mvc:mapping path="/setting/**"/>
<bean class="com.interceptor.LoginCheck"></bean>
</mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.interceptor.CityCheck"></bean>
</mvc:interceptor>
</mvc:interceptors>
<!-- spring && mina -->
<!-- executorFilter多线程处理 -->
<bean id="executorFilter" class="org.apache.mina.filter.executor.ExecutorFilter" />
<bean id="mdcInjectionFilter" class="org.apache.mina.filter.logging.MdcInjectionFilter">
<constructor-arg value="remoteAddress" />
</bean>
<bean id="codecFilter" class="org.apache.mina.filter.codec.ProtocolCodecFilter">
<constructor-arg>
<!-- <bean class="org.apache.mina.filter.codec.textline.TextLineCodecFactory" />-->
<!-- 处理对象流时候用ObjectSerializationCodecFactory -->
<!-- <bean class="org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory" /> -->
<bean class="com.umaiw.socket.ServerCodeFactory" />
</constructor-arg>
</bean>
<bean id="loggingFilter" class="org.apache.mina.filter.logging.LoggingFilter" />
<bean id="filterChainBuilder" class="org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder">
<property name="filters">
<map>
<entry key="executor" value-ref="executorFilter" />
<entry key="mdcInjectionFilter" value-ref="mdcInjectionFilter" />
<entry key="codecFilter" value-ref="codecFilter" />
<entry key="loggingFilter" value-ref="loggingFilter" />
</map>
</property>
</bean>
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="customEditors">
<map>
<entry key="java.net.SocketAddress">
<bean class="org.apache.mina.integration.beans.InetSocketAddressEditor" />
</entry>
</map>
</property>
</bean>
<!-- session config -->
<bean id="sessionConfig" factory-bean="ioAcceptor"
factory-method="getSessionConfig" >
<property name="readerIdleTime" value="50"/>
</bean>
<bean id="ioAcceptor" class="org.apache.mina.transport.socket.nio.NioSocketAcceptor" init-method="bind" destroy-method="unbind">
<property name="defaultLocalAddress" value=":10000" />
<property name="handler" ref="dataHandler" />
<property name="filterChainBuilder" ref="filterChainBuilder" />
<property name="reuseAddress" value="true" />
</bean>
<bean id="dataHandler" class="com.umaiw.socket.DataHandler">
</bean>
<!--这里是udp的部分 如果想用请下载udp部分的代码 会在最下面有下载-->
<!-
<bean id="udpAcceptor" class="org.apache.mina.transport.socket.nio.NioDatagramAcceptor" init-method="bind" destroy-method="unbind">
<property name="defaultLocalAddress" value=":10001" />
<property name="handler" ref="UdpHandler" />
<property name="filterChainBuilder" ref="filterChainBuilder" />
</bean>
<bean id="UdpHandler" class="com.umaiw.socket.UdpHandler">
</bean>
-->
</beans>如果需要数据库连接的话 再src下面再写个jdbc.properties具体怎么写大家都会把 好吧给个例子
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://你的数据库地址哦:3306/umaiwtest?relaxAutoCommit=true&zeroDateTimeBehavior=convertToNull
jdbc.username=test
jdbc.password=test
然后是DataHandler 处理各种事件的地方
其中的messageRecive方法里调用的
String result=constants.getClassName(Long.parseLong(command));
Command cmd = (Command)constants.newCommand(result);
cmd.action(session, other);
则是吧处理的业务逻辑写成了实现command的接口都有一个action方法
然后动态加载command这个对应名字类的方法
这里是按 : 来分隔参数的
package com.umaiw.socket;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.mina.core.future.CloseFuture;
import org.apache.mina.core.future.IoFuture;
import org.apache.mina.core.future.IoFutureListener;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.model.UserSession;
import com.model.umaiw_app_system;
import com.service.GetInitKeyService;
import com.service.implement.GetInitKeyServiceImpl;
import com.umaiw.command.Command;
import com.umaiw.command.Constants;
import com.umaiw.command.SocketModel;
import com.util.DesUtil;
@Component("DataHandler")
public class DataHandler extends IoHandlerAdapter implements Runnable{
@Autowired
private Constants constants;
private final static Logger log = LoggerFactory.getLogger(DataHandler.class);
private final Set<IoSession> sessions = Collections.synchronizedSet(new HashSet<IoSession>());
//private UserSession UserSession;
@Autowired
private static Map<String,IoSession> users = Collections.synchronizedMap(new HashMap<String,IoSession>());
@Override
public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
log.error(" 有异常发生时被触发exceptionCaught。",cause);
session.close(true);
}
@Override
public void sessionCreated(IoSession session) throws Exception {
log.info("当创建一个新连接时被触发，即当开始一个新的Session时被触发。");
log.info("创建一个新连接：{}", session.getRemoteAddress());
/*//50秒无读写操作就触发idele
session.getConfig().setIdleTime(IdleStatus.BOTH_IDLE, 50);*/
sessions.add(session);
log.info("并发的个数:\t"+sessions.size());
session.setAttribute("command",1);
messageSentSingle(session, "创建了一个socket连接哦");
}
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
log.info("服务器接收到数据： {}", message);
String[] mes=message.toString().split(":");
String version=mes[0];//协议版本号
String ID=mes[1];//包ID(10进制)
String mark=mes[2];//唯一标识
String mobile=mes[3];//手机号码
String command=mes[4];//命令ID(10进制)
String[] other=new String[mes.length*2];
if(mes.length>5){
for(int i=5;i<mes.length;i++){
int x=0;
other[x]=mes[i];
x++;
}
}
if(mobile==null){
mobile="1";
}
session.setAttribute("mobile",mobile);
String result=constants.getClassName(Long.parseLong(command));
Command cmd = (Command)constants.newCommand(message);
cmd.action(session, message);
Object oldpacket_id=session.getAttribute("packet_id");
if(oldpacket_id!=null){
session.setAttribute("oldpacket_id",oldpacket_id);
}
String packet_id=new Date().getTime()+"";
session.setAttribute("packet_id",packet_id);
session.setAttribute("command",Integer.parseInt(command));
// messageSentSingle(session, "业务处理完了");
}
public static void messageSentAll( Object message) throws Exception {
log.info("发送消息时时被触发，即在调用IoSession.write()时被触发，message代表将要发送的消息。=" + message);
// 向所有客户端发送的数据
SocketModel socm=new SocketModel(new Date().getTime()+"", "", 5, message);
String send=socm.toString();
Collection<IoSession> sessions = users.values();
for (IoSession sess : sessions) {
sess.write(send);
}
}
public static void messageSentSingle(IoSession session, Object message) throws Exception {
log.info("发送消息时时被触发，即在调用IoSession.write()时被触发，message代表将要发送的消息。=" + message);
// 向所有客户端发送的数据
Integer command=(Integer) session.getAttribute("command");
SocketModel socm=new SocketModel(new Date().getTime()+"", "", command, message);
String send=socm.toString();
session.write(send);
}
public static void messageSentPart( Object message,String city_id) throws Exception {
log.info("发送消息时时被触发，即在调用IoSession.write()时被触发，message代表将要发送的消息。=" + message);
Object[] key=users.keySet().toArray();
for (int i = 0; i < key.length; i++) {
if(key[i].toString().contains(city_id)){
IoSession iosession=users.get(key[i]);
SocketModel socm=new SocketModel(new Date().getTime()+"", "", 5, message);
String send=socm.toString();
iosession.write(send);
}
}
// 向所有客户端发送的数据
}
public static Map<String, IoSession> getUsers() {
return users;
}
@Override
public void sessionClosed(IoSession session) throws Exception {
log.info("关闭当前session：{}#{}", session.getId(), session.getRemoteAddress());
CloseFuture closeFuture = session.close(true);
closeFuture.addListener(new IoFutureListener<IoFuture>() {
public void operationComplete(IoFuture future) {
if (future instanceof CloseFuture) {
((CloseFuture) future).setClosed();
log.info("sessionClosed CloseFuture setClosed-->{},", future.getSession().getId());
}
}
});
UserSession userSession= (UserSession) session.getAttribute("UserSession");
String mobile=(String) session.getAttribute("mobile");
if(null!=mobile&&userSession!=null){
users.remove(mobile+"+"+userSession.getCity_id());
}
sessions.remove(session);
log.info("关闭的连接的剩余的个数：\t"+sessions.size());
}
@Override
public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
// session.close();
log.info("IDLE " + session.getIdleCount(status)+"次;"+"user个数"+users.size()+"sessions个数"+sessions.size());
if(session.getIdleCount(status) > 5){
log.info("连接空闲= " + session.getIdleCount(status)+",触发session关闭");
session.close(true);
}
}
@Override
public void sessionOpened(IoSession session) throws Exception {
log.info("进入当打开一个连接时被触发sessionOpened！");
log.info("打开一个session：{}#{}", session.getId(), session.getBothIdleCount());
try {
super.sessionOpened(session);
} catch (Exception e) {
log.error("",e);
}
}
@Override
public void messageSent(IoSession session, Object message) throws Exception {
log.info("发送消息时时被触发，即在调用IoSession.write()时被触发，message代表将要发送的消息。=" + message);
try {
super.messageSent(session, message);
} catch (Exception e) {
log.error("",e);
}
}
}
}然后是处理业务逻辑的command接口 和实现它的类（这里就举1个例子，多写业务处理 就再多些点实现类就行）
command.java
package com.umaiw.command;
import org.apache.mina.core.session.IoSession;
public interface Command {
public void action(IoSession session,String[] other) ;
}UMMSG_TCP_SENDINFORMATIONTOSERVER.java（业务逻辑处理）
package com.umaiw.command;
import org.apache.mina.core.session.IoSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import com.model.UserSession;
import com.service.LoginService;
import com.service.implement.LoginServiceImpl;
import com.umaiw.socket.DataHandler;
@Component("UMMSG_TCP_SENDINFORMATIONTOSERVER")
public class UMMSG_TCP_SENDINFORMATIONTOSERVER implements Command {
@Autowired
private LoginService loginService ;
@Override
public void action(IoSession session, String[] param) {
String mobile=(String) session.getAttribute("mobile");
UserSession user= loginService.getUserSession(mobile);
session.setAttribute("UserSession",user);
DataHandler.getUsers().put(mobile+"+"+user.getCity_id(), session);
// DataHandler.messageSentSingle(session, s);
}
}接下来是根据传过来的command来找是哪个处理类的类
Constants.java
这里注册了三个类（上面给了一个类UMMSG_TCP_SENDINFORMATIONTOSERVER的例子，别的照着写就行啦）
package com.umaiw.command;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component("Constants")
public class Constants {
@Autowired
private UMMSG_TCP_CHECKCLIENT uMMSG_TCP_CHECKCLIENT;
@Autowired
private UMMSG_TCP_MAKESURECEIVE uMMSG_TCP_MAKESURECEIVE;
@Autowired
private UMMSG_TCP_SENDINFORMATIONTOSERVER uMMSG_TCP_SENDINFORMATIONTOSERVER;
@Autowired
private Map<String, Object> registry = new HashMap<String, Object>();
@Autowired
private void res() {
// 2、客户端发送口令供服务器端验证
registry.put(UMMSG_TCP_CHECKCLIENT_name, uMMSG_TCP_CHECKCLIENT);
// 3、客户端发送身份信息给服务器
registry.put(UMMSG_TCP_SENDINFORMATIONTOSERVER_name,
uMMSG_TCP_SENDINFORMATIONTOSERVER);
// 4、客户端发送回执给服务器
registry.put(UMMSG_TCP_MAKESURECEIVE_name, uMMSG_TCP_MAKESURECEIVE);
}
// 方法对应值与类名
// 2、客户端发送口令供服务器端验证
public static final int UMMSG_TCP_CHECKCLIENT_code = 0x00000002;
public static final String UMMSG_TCP_CHECKCLIENT_name = "UMMSG_TCP_CHECKCLIENT";
// 3、客户端发送身份信息给服务器
public static final int UMMSG_TCP_SENDINFORMATIONTOSERVER_code = 0x00000003;
public static final String UMMSG_TCP_SENDINFORMATIONTOSERVER_name = "UMMSG_TCP_SENDINFORMATIONTOSERVER";
// 4、客户端发送回执给服务器
public static final int UMMSG_TCP_MAKESURECEIVE_code = 0x00000004;
public static final String UMMSG_TCP_MAKESURECEIVE_name = "UMMSG_TCP_MAKESURECEIVE";
// 注册到registry集合里好使用
public String getClassName(long code) {
if (code == UMMSG_TCP_SENDINFORMATIONTOSERVER_code) {
return UMMSG_TCP_SENDINFORMATIONTOSERVER_name;
} else if (code == UMMSG_TCP_SENDINFORMATIONTOSERVER_code) {
return UMMSG_TCP_SENDINFORMATIONTOSERVER_name;
} else if (code == UMMSG_TCP_MAKESURECEIVE_code) {
return UMMSG_TCP_MAKESURECEIVE_name;
} else if (code == UMMSG_TCP_CHECKCLIENT_code) {
return UMMSG_TCP_CHECKCLIENT_name;
}
return null;
}
public Object newCommand(String name) {
return registry.get(name);
}
// 获得无符号值
public static int getUnsignedValue(byte bt) {
int i = bt;
if (bt < 0) {
i = 257 + i;
}
return i;
}
// 获得无符号值
public static long getLongValue(byte[] bt) {
long l = 0;
for (int i = 0; i < bt.length; i++) {
l = (l << 8) | (bt[i] & 0xff);
}
return l;
}
public String getClassName(byte[] bt) {
return getClassName(getLongValue(bt));
}
/**
* @since Integer转换byte[]
* @param len
* @return
*/
public static byte[] getByteByInt(Integer len, int buffer) {
byte[] b = new byte[buffer];
for (int i = b.length - 1; i > -1; i--) {
b[i] = new Integer(len & 0xff).byteValue();// 将最高位保存在最低位
len = len >> 8; // 向右移8位
}
return b;
}
public static byte[] getByteByStr(String len, int buffer) {
byte[] bt = new byte[buffer];
System.arraycopy(len.getBytes(), 0, bt, 0, len.getBytes().length);
return bt;
}
public static void main(String[] args) {
// getByteByStr("123", 6);
// byte[] bt = new byte[4];
// bt[0] = (byte) 0x00;
// bt[1] = (byte) 0x00;
// bt[2] = (byte) 0x00;
// bt[3] = (byte) 0x01;
// System.out.println(Constants.getLongValue(bt));
// System.out.println(Constants.getLongValue(Constants
// .getByteByInt(110, 4)));
// getByteByInt(0x10000001, 4);
System.err.println(Integer.MAX_VALUE);
}
}接下来是socketmodel 就是用来整理发送消息的格式的
SocketModel.java
package com.umaiw.command;
public class SocketModel {
private String version="UM";
private String id;
private String mark="";
private String mobile;
private Object other;
private Integer command;
public SocketModel( String id, String mobile,
Integer command,Object other) {
this.id = id;
this.mobile = mobile;
this.other = other;
this.command = command;
}
public String toString() {
return version+":"+id+":"+mark+":"+mobile+":"+command+":"+other+(char)7;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getMark() {
return mark;
}
public void setMark(String mark) {
this.mark = mark;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
public Object getOther() {
return other;
}
public void setOther(Object other) {
this.other = other;
}
public Integer getCommand() {
return command;
}
public void setCommand(Integer command) {
this.command = command;
}
}最后是mina必备的codefactory和decode，encode
ServerCodeFactory.java
package com.umaiw.socket;
import java.nio.charset.Charset;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFactory;
import org.apache.mina.filter.codec.ProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolEncoder;
import org.apache.mina.filter.codec.textline.LineDelimiter;
import org.apache.mina.filter.codec.textline.TextLineDecoder;
import org.apache.mina.filter.codec.textline.TextLineEncoder;
public class ServerCodeFactory implements ProtocolCodecFactory {
private final ProtocolEncoder encoder;
private final ProtocolDecoder decoder;
/*final static char endchar = 0x1a;*/
final static char endchar = 0x0d;
public ServerCodeFactory() {
this(Charset.forName("utf-8"));
}
public ServerCodeFactory(Charset charset) {
encoder = new CharsetEncoder();
decoder = new CharsetDecoder();
}
@Override
public ProtocolDecoder getDecoder(IoSession session) throws Exception {
// TODO Auto-generated method stub
return decoder;
}
@Override
public ProtocolEncoder getEncoder(IoSession session) throws Exception {
// TODO Auto-generated method stub
return encoder;
}
public ProtocolEncoder getEncoder() {
return encoder;
}
public ProtocolDecoder getDecoder() {
return decoder;
}
}CharsetDecoder.java （这里用(char)7当结束标志）
package com.umaiw.socket;
import java.nio.charset.Charset;
import org.apache.log4j.Logger;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
/**
* <b>function:</b> 字符解码
* @author hoojo
* @createDate 2012-6-26 上午11:14:18
* @file CharsetDecoder.java
* @package com.hoo.mina.code
* @project ApacheMiNa
* @blog http://blog.csdn.net/IBM_hoojo
* @email hoojo_@126.com
* @version 1.0
*/
public class CharsetDecoder implements ProtocolDecoder {
private final static Logger log = Logger.getLogger(CharsetDecoder.class);
private final static Charset charset = Charset.forName("UTF-8");
// 可变的IoBuffer数据缓冲区
private IoBuffer buff = IoBuffer.allocate(100).setAutoExpand(true);
@Override
public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
log.info("#########decode#########");
// 如果有消息
while (in.hasRemaining()) {
// 判断消息是否是结束符，不同平台的结束符也不一样；
// windows换行符（\r\n）就认为是一个完整消息的结束符了； UNIX 是\n；MAC 是\r
byte b = in.get();
if (b == (char)7) {
buff.flip();
byte[] bytes = new byte[buff.limit()];
buff.get(bytes);
String message = new String(bytes, charset);
buff = IoBuffer.allocate(100).setAutoExpand(true);
// 如果结束了，就写入转码后的数据
out.write(message);
log.info("message: " + message);
} else {
buff.put(b);
}
}
}
@Override
public void dispose(IoSession session) throws Exception {
log.info("#########dispose#########");
log.info(session.getCurrentWriteMessage());
}
@Override
public void finishDecode(IoSession session, ProtocolDecoderOutput out) throws Exception {
log.info("#########完成解码#########");
}
}CharsetEncoder.java
package com.umaiw.socket;
import java.nio.charset.Charset;
import org.apache.log4j.Logger;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolEncoder;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;
import org.apache.mina.filter.codec.textline.LineDelimiter;
/**
* <b>function:</b> 字符编码
* @author hoojo
* @createDate 2012-6-26 上午11:32:05
* @file CharsetEncoder.java
* @package com.hoo.mina.code
* @project ApacheMiNa
* @blog http://blog.csdn.net/IBM_hoojo
* @email hoojo_@126.com
* @version 1.0
*/
public class CharsetEncoder implements ProtocolEncoder {
private final static Logger log = Logger.getLogger(CharsetEncoder.class);
private final static Charset charset = Charset.forName("UTF-8");
@Override
public void dispose(IoSession session) throws Exception {
log.info("#############dispose############");
}
@Override
public void encode(IoSession session, Object message, ProtocolEncoderOutput out) throws Exception {
log.info("#############字符编码############");
IoBuffer buff = IoBuffer.allocate(100).setAutoExpand(true);
buff.putString(message.toString(), charset.newEncoder());
// put 当前系统默认换行符
// buff.putString(LineDelimiter.DEFAULT.getValue(), charset.newEncoder());
// 为下一次读取数据做准备
buff.flip();
out.write(buff);
}
}
1007
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
