服务端:
第一步:编写实体类User、 Sex枚举类、FCMessage类
实体类User
<em>package com.durian.fc.entity;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable{
/**
* 在线 1
*/
private static final int ONLINE = 1;
/**
* 离线 2
*/
private static final int OUTLINE = 2;
/**
* 隐身 3
*/
private static final int INVISIBLE = 3;
/**
* 断线 4
*/
private static final int BREAK = 4;
/**
* id唯一标示,主键
*/
private int id;
/**
* 账号,唯一不为空
*/
private int account;
/**
* 昵称
*/
private String nickName;
/**
* 真实姓名
*/
private String realName;
/**
* 性别 枚举
*/
private Sex sex;
/**
* 密码,不为空
*/
private String password;
/**
* 生日
*/
private Date birthday;
/**
* 个性签名
*/
private String signature;
/**
* 操作标记:登陆/注册......
*/
private String operation;
/**
* 登录状态
*/
private int state = User.ONLINE;
/**
* 无参构造函数
*/
public User() {
super();
}
/**
* 有参构造函数
* @param account 账号
* @param password 密码
*/
public User(int account, String password) {
super();
this.account = account;
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAccount() {
return account;
}
public void setAccount(int account) {
this.account = account;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
public Sex getSex() {
return sex;
}
public void setSex(Sex sex) {
this.sex = sex;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSignature() {
return signature;
}
public void setSignature(String signature) {
this.signature = signature;
}
public String getOperation() {
return operation;
}
public void setOperation(String operation) {
this.operation = operation;
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}</em>
枚举类Sex
<em>package com.durian.fc.entity;
public enum Sex {
male ,female;
}</em>
实体类FCMessage
<em>package com.durian.fc.entity;
import java.io.Serializable;
import java.util.Date;
public class FCMessage implements Serializable{
public static final String SUCCESS="1";//表明是否成功
public static final String FAIL="2";//表明失败
public static final String COM_MES="3";//普通信息包
public static final String GET_ONLINE_FRIENDS="4";//要求在线好友的包
public static final String RET_ONLINE_FRIENDS="5";//返回在线好友的包
public static final String LOGIN="7";//请求验证登陆
public static final String ADD_BUDDY="8";//添加好友
public static final String DEL_BUDDY="9";//删除好友
public static final String GROUP_MES="10";//群消息
/**
* 信息类型
*/
private String type;
/**
* 信息发送者
*/
private int sender;
/**
* 信息发送者昵称
*/
private String senderNick;
/**
* 信息发送者头像图片
*/
private String senderAvatar;
/**
* 信息接受者
*/
private int receiver;
/**
* 信息内容
*/
private String content;
/**
* 信息发送时间
*/
private Date sendtime;
/**
*
*/
private int gaccount;
/**
*
*/
private String groupNick;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getSender() {
return sender;
}
public void setSender(int sender) {
this.sender = sender;
}
public String getSenderNick() {
return senderNick;
}
public void setSenderNick(String senderNick) {
this.senderNick = senderNick;
}
public String getSenderAvatar() {
return senderAvatar;
}
public void setSenderAvatar(String senderAvatar) {
this.senderAvatar = senderAvatar;
}
public int getReceiver() {
return receiver;
}
public void setReceiver(int receiver) {
this.receiver = receiver;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Date getSendtime() {
return sendtime;
}
public void setSendtime(Date sendtime) {
this.sendtime = sendtime;
}
public int getGaccount() {
return gaccount;
}
public void setGaccount(int gaccount) {
this.gaccount = gaccount;
}
public String getGroupNick() {
return groupNick;
}
public void setGroupNick(String groupNick) {
this.groupNick = groupNick;
}
}</em>
第二步:编写User.hbm.xml映射文件
<strong><?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 该文件为hibernate的映射文件,映射的实体类为User,对应的数据库表为t_user -->
<hibernate-mapping
package="com.durian.fc.entity">
<class name="User" table="t_user">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="account" column="account" unique="true" not-null="true"/>
<property name="nickName" column="nickname"/>
<property name="realName" column="realname"/>
<property name="sex" column="sex"/>
<property name="password" column="password" not-null="true"/>
<property name="birthday" column="birthday"/>
<property name="signature" column="signature"/>
<property name="operation" column="operation"/>
<property name="state" column="state"/>
</class>
</hibernate-mapping></strong>
第三步:编写Hibernate.cfg.xml的配置文件
<strong><!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<!-- hibernate的配置文件-->
<hibernate-configuration>
<session-factory>
<!-- 设置连接的驱动类 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 设置连接的数据库 -->
<property name="connection.url">jdbc:mysql:///fc</property>
<!-- 设置MYSQL数据库的用户名 -->
<property name="connection.username">root</property>
<!-- 设置MYSQL数据库用户的密码 -->
<property name="connection.password"></property>
<!-- 设置连接的数据库方言 -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hbm2ddl.auto">update</property>
<!-- 设置是否显示sql语句 -->
<property name="show_sql">true</property>
<!-- 设置映射的资源路径文件 -->
<mapping resource="com/durian/fc/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration></strong>
第四步:编写Util工具类
<strong>package com.durian.fc.utils;
import java.io.Serializable;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public final class HibernateUtils {
private static SessionFactory sessionFactory;
private HibernateUtils(){}
//实际上是一个Map集合
public static ThreadLocal session = new ThreadLocal();
static{
/*
* 下面三句是
* hibernate初始化的过程,整个过程在程序里面只能做一次,
* 非常耗时,
* 需要解析配置文件和映射文件
*/
Configuration cfg = new Configuration();
cfg.configure();
sessionFactory = cfg.buildSessionFactory();
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
public static Session getThreadLocalSession(){
Session s = (Session)session.get();
if(s == null){
s = getSession();
session.set(s);
}
return s;
}
public static void closeSession(){
Session s = (Session)session.get();
if(s != null){
s.close();
session.set(null);
}
}
public static Session getSession(){
return sessionFactory.openSession();
}
public static void add(Object entity){
Session s = null;
Transaction tx = null;
try {
s = HibernateUtils.getSession();
tx = s.beginTransaction();
s.save(entity);
tx.commit();
}finally{
if(s !=null){
s.close();
}
}
}
public static void update(Object entity){
Session s = null;
Transaction tx = null;
try {
s = HibernateUtils.getSession();
tx = s.beginTransaction();
s.update(entity);
tx.commit();
}finally{
if(s !=null){
s.close();
}
}
}
public static void delete(Object entity){
Session s = null;
Transaction tx = null;
try {
s = HibernateUtils.getSession();
tx = s.beginTransaction();
s.delete(entity);
tx.commit();
}finally{
if(s !=null){
s.close();
}
}
}
public static Object get(Class clazz,Serializable id){
Session s = null;
try {
s = HibernateUtils.getSession();
Object obj = s.get(clazz, id);
return obj;
}finally{
if(s !=null){
s.close();
}
}
}
}</strong>
第五步:为了后面工程的扩展,编写一个公共接口文件和实现基类公共接口BaseDao
<em>package com.durian.fc.dao.base;
import java.util.List;
/**
* 通用接口BaseDao,
* 该接口提取了常用的方法
*/
public interface BaseDao<T> {
/**
* 获取记录总数
* @param entityClass 实体类
*/
public long getCount(Class<T> entityClass);
/**
* 保存实体
* @param entity
*/
public T save(T entity);
/**
* 更新实体数据
*/
public T update(T entity);
/**
* 删除实体
* @param entity 实体
*/
public T delete(T entity);
/**
* 删除一组实体
* @param entityList 实体类集合
*/
public List<T> delete(List<T> entityList);
/**
* 获取实体
* @param entityId 实体Id
*/
public T findEntityById(Class<T> entityClass,int entityId);
/**
* 获取所有实体
*/
public List<T> findAllEntity(Class<T> entityClass);
/**
* 模糊搜索
* @return
*/
public List<T> findEntityByFuzzy(Class<T> entityClass,String matchStr);
}</em>
BaseDaoImpl实现类
<em>package com.durian.fc.dao.base;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.durian.fc.utils.HibernateUtils;
/**
* 抽象类BaseDaoImpl,
* 实现了BaseDao接口
* 该接口提取了常用的方法
*/
@Transactional
@Repository
public abstract class BaseDaoImpl<T> implements BaseDao<T> {
// 声明一个session,用于会话
Session session = null;
// 声明一个transaction用于事务的控制
Transaction tx = null;
/**
* 获取记录总数
* @param entityClass 实体类
*/
@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
@Override
public long getCount(Class<T> entityClass) {
//定义一个字符串将传进来的类名转换成字符串格式,以便进行HQL查询拼接
String className = entityClass.getName();
try {
// 通过工具类获取一个线程会话
session = HibernateUtils.getThreadLocalSession();
// 创建一个HQL语句,用于查询数据库中的实体
String hql = "from " + className;
// 通过session创建一个HQL的查询语句
Query query = session.createQuery(hql);
// 该方法获得的查询结果存放到一个list集合中
List<T> lists = query.list();
// 如果实体存在则返回该实体的总条数
if (lists.size() > 0) {
return lists.size();
} else {
// 否则返回空
System.out.println("该表为空");
return -1;
}
} finally {
// 通过工具类关闭session,在finally里面的代码是一定会执行的
HibernateUtils.closeSession();
}
}
/**
* 保存实体
* @param entity
*/
@Override
public T save(T entity) {
try {
session = HibernateUtils.getThreadLocalSession();
tx = session.beginTransaction();
session.save(entity);
tx.commit();
} catch (Exception e) {
if (tx != null)
tx.rollback();
throw new RuntimeException(e.getMessage(), e);
} finally {
HibernateUtils.closeSession();
}
System.out.println("保存成功");
return entity;
}
/**
* 更新实体数据
*/
@Override
public T update(T entity) {
try {
session = HibernateUtils.getThreadLocalSession();
tx = session.beginTransaction();
session.update(entity);
tx.commit();
} catch (Exception e) {
if (tx != null)
tx.rollback();
throw new RuntimeException(e.getMessage(), e);
} finally {
HibernateUtils.closeSession();
}
System.out.println("更新成功");
return entity;
}
/**
* 删除实体
* @param entity 实体
*/
@Override
public T delete(T entity) {
try {
session = HibernateUtils.getThreadLocalSession();
tx = session.beginTransaction();
session.delete(entity);
tx.commit();
} catch (Exception e) {
if (tx != null)
tx.rollback();
throw new RuntimeException(e.getMessage(), e);
} finally {
HibernateUtils.closeSession();
}
System.out.println("删除成功");
return entity;
}
/**
* 删除一组实体
* @param entityList 实体类集合
*/
@Override
public List<T> delete(List<T> entityList) {
// 通过加强for循环,将需要删除的集合内的所有对象删除
for (T t : entityList) {
try {
session = HibernateUtils.getThreadLocalSession();
tx = session.beginTransaction();
session.delete(t);
tx.commit();
} catch (Exception e) {
if (tx != null)
tx.rollback();
throw new RuntimeException(e.getMessage(), e);
} finally {
HibernateUtils.closeSession();
}
}
System.out.println("删除成功");
return entityList;
}
/**
* 获取实体
* @param entityId 实体Id
*/
@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
@Override
public T findEntityById(Class<T> entityClass, int entityId) {
try {
session = HibernateUtils.getThreadLocalSession();
T pId = (T) session.get(entityClass, entityId);
if (pId != null) {
return pId;
} else {
System.out.println("该结果不存在");
return null;
}
} finally {
HibernateUtils.closeSession();
}
}
/**
* 获取所有实体
*/
@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
@Override
public List<T> findAllEntity(Class<T> entityClass) {
String className = entityClass.getName();
try {
session = HibernateUtils.getThreadLocalSession();
String hql = "from "+className;
Query query = session.createQuery(hql);
List<T> lists = query.list();
if (lists.size() > 0) {
return lists;
} else {
System.out.println("该表为空");
return null;
}
} finally {
HibernateUtils.closeSession();
}
}
/**
* 模糊搜索
* @return
*/
public List<T> findEntityByFuzzy(Class<T> entityClass,String matchStr){
String className = entityClass.getName();
try {
session = HibernateUtils.getThreadLocalSession();
String hql = "from "+className +" as cn where cn.name like '%" + matchStr +"%'";
Query query = session.createQuery(hql);
List<T> lists = query.list();
if (lists.size() > 0) {
return lists;
} else {
System.out.println("该表为空");
return null;
}
} finally {
HibernateUtils.closeSession();
}
}
}</em>
第六步:编写UserDao接口及其实现类UserDaoImpl实现类
UserDao接口
<em>package com.durian.fc.dao.user;
import com.durian.fc.dao.base.BaseDao;
import com.durian.fc.entity.User;
public interface UserDao extends BaseDao<User> {
/**
* 通过账号查找用户
* @param account
* @return
*/
public User findUserByAccount(int account);
}</em>
UserDaoImpl实现类
<em>package com.durian.fc.dao.user;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.durian.fc.dao.base.BaseDaoImpl;
import com.durian.fc.entity.User;
import com.durian.fc.utils.HibernateUtils;
public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao {
// 声明一个session,用于会话
Session session = null;
// 声明一个transaction用于事务的控制
Transaction tx = null;
@Override
public User findUserByAccount(int account) {
try {
// 通过工具类获取一个线程会话
session = HibernateUtils.getThreadLocalSession();
// 创建一个通过innerDepartment查询的HQL语句,用于查询数据库中的信息
String hql = "from User as u where u.account=?";
// 通过session创建一个HQL的查询语句
Query query = session.createQuery(hql);
// 设置查询语句中的第一个通配符值
query.setInteger(0, account);
// 该方法获得的查询结果是一个集合
User u = (User) query.uniqueResult();
// 如果存在则返回结果
if (u != null) {
return u;
} else {
// 否则返回空
System.out.println("用户不存在");
return null;
}
} finally {
// 通过工具类关闭session,在finally里面的代码是一定会执行的
HibernateUtils.closeSession();
}
}
}</em>
第七步:编写FCService类
<strong>package com.durian.fc.service;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import com.durian.fc.dao.user.UserDao;
import com.durian.fc.dao.user.UserDaoImpl;
import com.durian.fc.entity.FCMessage;
import com.durian.fc.entity.User;
public class FCServer {
public FCServer(){
ServerSocket ss = null;
try {
ss = new ServerSocket(9999);
System.out.println("服务器已启动,正在监听9999端口...");
while(true){
//接受客户端的socket连接
Socket s = ss.accept();
//接受客户发来的信息
ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
User user = (User)ois.readObject();
//创建一个信息,用于保存发送给客户端的信息
FCMessage msg = new FCMessage();
ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
//判断客户端的操作类型是否为:登陆操作
if(user.getOperation().equals("login")){
int account = user.getAccount();
String password = user.getPassword();
UserDao ud = new UserDaoImpl();
//查询mysql数据库中的表数据
User u = ud.findUserByAccount(account);
if(u != null && account==u.getAccount() && password.equals(u.getPassword())){
System.out.println("["+account+"]上线了!");
msg.setType(FCMessage.SUCCESS);
oos.writeObject(msg);
//单开一个线程,让该线程与该客户端保持连接
//此步骤待定
}else{
msg.setType(FCMessage.FAIL);
oos.writeObject(msg);
}
}else if(user.getOperation().equals("register")){
//注册待定
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}</strong>
最后写一个LoginServerTest开启socket
package com.durian.fc.test;
import com.durian.fc.service.FCServer;
public class LoginServerTest {
/**
* @param args
*/
public static void main(String[] args) {
FCServer fcs = new FCServer();
}
}