Android客户端与PC服务端之间的SOCKET实现登陆功能（服务器）

最新推荐文章于 2021-11-21 00:01:36 发布

aobingque

最新推荐文章于 2021-11-21 00:01:36 发布

阅读量973

点赞数

服务端：
第一步：编写实体类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();
    }
}

aobingque

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Android客户端与PC服务端之间的SOCKET实现登陆功能（服务器）

服务端：第一步：编写实体类User、 Sex枚举类、FCMessage类实体类Userpackage com.durian.fc.entity;import java.io.Serializable;import java.util.Date;public class User implements Serializable{ /** * 在线 1
复制链接

扫一扫