结合以前一个项目，将普通的jdbc进行了相关整合，全部改写成了hibernate接口

项目名称：短视频分享平台

主要功能：用户模块：注册、登录、编辑资料、查看用户相关

分类模块：分类添加、查看

视频共享模块：查看、上传、删除

点赞模块：是否已赞、点赞

评论模块：评论、查看

关注模块：关注、查看关注列表、是否已关注、取消关注

实体类：

用户 User

分类 Find

视频信息 Video

点赞信息 Praise

评论信息 Post

关注信息 Follow

对应关系：  一个用户对应多个视频，对应多条评论，对应多个点赞信息，对应多个关注信息。

一个分类对应多个视频

一个视频对应一个分类，对应一个用户，对应多个点赞信息，对应多个评论信息

　　　　　 一个赞对应一个用户，对应一个视频

一条评论对应一个用户，对应一个视频

一个关注对应一个用户

实体类：

1.User

  1. public class User{
  2.         private Integer userID;
  3.     private String username;
  4.     private String password;
  5.     private String sex;
  6.     private String email;
  7.     private String priority;
  8.     private String icon;
  9.     private String introduce;
  10.  
  11.     private Set<Video> videos = new HashSet<>();
  12.     private Set<Post> posts = new HashSet<>();
  13.     private Set<Praise> praises = new HashSet<>();
  14.  
  15.     private Set<Follow> follows1 = new HashSet<>();
  16.     private Set<Follow> follows2 = new HashSet<>();
  17.         //get and set方法
  18.         ......
  19. }

2.Find

  1. public class Find {
  2. private int ID;
  3. private String find;
  4.  
  5. private Set<Video> videos = new HashSet<>();
  6.       //get and set
  7.       ......
  8. }

3.Video

  1. public class Video{
  2.     private int videoID;
  3.     private String content;
  4.     private Timestamp date;
  5.     private String path;
  6.     private int viewNum;
  7.     private String isuse;
  8.     private User user;
  9.     private Find find;
  10.  
  11.     private Set<Post> posts = new HashSet<>();
  12.     private Set<Praise> praises = new HashSet<>();
  13.         //get and set
  14.         ......
  15. }

4.Post

  1. public class Post {
  2.     private int postID;
  3.     private String content;
  4.     private Timestamp date;
  5.  
  6.     private Video video;
  7.     private User user;
  8.         //get and set
  9.         ......
  10. }

5.Praise

  1. public class Praise {
  2.     private Integer praiseID;
  3.  
  4.     private Video video;
  5.     private User user;
  6.         //get and set
  7.         ......
  8. }

6.Follow

  1. public class Follow {
  2.     private int followID;
  3.  
  4.     private User user1;
  5.     private User user2;
  6.        //get and set
  7.        ......
  8. }

实体配置

1.User.hbm.xml

  1. <hibernate-mapping>
  2.     <class name="bean.User" table="user">
  3.         <id name="userID" column="userID">
  4.             <generator class="native"></generator>
  5.         </id>
  6.         <property name="username" length="16"></property>
  7.         <property name="password" length="16"></property>
  8.         <property name="sex" length="16"></property>
  9.         <property name="email" ></property>
  10.         <property name="priority"></property>
  11.         <property name="icon"></property>
  12.         <property name="introduce"></property>
  13.  
  14.         <set name="videos" inverse="true">
  15.             <key column="userID"></key>
  16.             <one-to-many class="bean.Video"/>
  17.         </set>
  18.         <set name="posts" inverse="true">
  19.             <key column="userID"></key>
  20.             <one-to-many class="bean.Post"/>
  21.         </set>
  22.         <set name="praises" inverse="true">
  23.             <key column="userID"></key>
  24.             <one-to-many class="bean.Praise"/>
  25.         </set> 
  26.  
  27.         <set name="follows1" inverse="true">
  28.             <key column="user1"></key>
  29.             <one-to-many class="bean.Follow"/>
  30.         </set>
  31.         <set name="follows2" inverse="true">
  32.             <key column="user2"></key>
  33.             <one-to-many class="bean.Follow"/>
  34.         </set>
  35.     </class>
  36. </hibernate-mapping>

2.Find.hbm.xml

  1. <hibernate-mapping>
  2.     <class name="bean.Find" table="find">
  3.         <id name="ID" column="ID">
  4.             <generator class="native"></generator>
  5.         </id>
  6.         <property name="find" length="64"></property>
  7.         <set name="videos">
  8.             <key column="findID"></key>
  9.             <one-to-many class="bean.Video"/>
  10.         </set>
  11.     </class>
  12. </hibernate-mapping>

3.Video.hbm.xml

  1. <hibernate-mapping>
  2.     <class name="bean.Video" table="video">
  3.         <id name="videoID" column="videoID">
  4.             <generator class="native"></generator>
  5.         </id>
  6.         <property name="content"></property>
  7.         <property name="date"></property>
  8.         <property name="path"></property>
  9.         <property name="viewNum"></property>
  10.         <property name="isuse"></property>
  11.  
  12.         <set name="posts" cascade="delete">
  13.             <key column="videoID"></key>
  14.             <one-to-many class="bean.Post"/>
  15.         </set>
  16.         <set name="praises" cascade="delete">
  17.             <key column="videoID"></key>
  18.             <one-to-many class="bean.Praise"/>
  19.         </set> 
  20.  
  21.         <many-to-one name="user" class="bean.User" column="userID"></many-to-one>
  22.         <many-to-one name="find" class="bean.Find" column="findID"></many-to-one>
  23.     </class>
  24. </hibernate-mapping>

4.Praise.hbm.xml

  1. <hibernate-mapping>
  2.     <class name="bean.Praise" table="praise">
  3.         <id name="praiseID" column="praiseID">
  4.             <generator class="native"></generator>
  5.         </id>
  6.  
  7.         <many-to-one name="user" class="bean.User" column="userID"></many-to-one>
  8.         <many-to-one name="video" class="bean.Video" column="videoID"></many-to-one>
  9.     </class>
  10. </hibernate-mapping>

5.Post.hbm.xml

  1. <hibernate-mapping>
  2.     <class name="bean.Post" table="post">
  3.         <id name="postID" column="postID">
  4.             <generator class="native"></generator>
  5.         </id>
  6.         <property name="content"></property>
  7.         <property name="date"></property>
  8.  
  9.         <many-to-one name="user" class="bean.User" column="userID"></many-to-one>
  10.         <many-to-one name="video" class="bean.Video" column="videoID"></many-to-one>
  11.     </class>
  12. </hibernate-mapping>

6.Follow.hbm.xml

  1. <hibernate-mapping>
  2.     <class name="bean.Follow" table="follow">
  3.         <id name="followID" column="followID">
  4.             <generator class="native"></generator>
  5.         </id>
  6.  
  7.         <many-to-one name="user1" class="bean.User" column="user1"></many-to-one>
  8.         <many-to-one name="user2" class="bean.User" column="user2"></many-to-one>
  9.     </class>
  10. </hibernate-mapping>

dao层

用户dao

  1. public class UserDaoImpl extends AbstractDao implements UserDao{
  2.  
  3.     @Override
  4.     public int addUser(User user) {
  5.         if (queryUserByUsername(user)!=null) {
  6.             return 404;
  7.         }
  8.         SessionFactory sessionFactory = null;
  9.         Session session = null;
  10.         Transaction transaction =null;
  11.         try {
  12.             sessionFactory = HibernateUtil.getSessionFactory();
  13.             session = sessionFactory.getCurrentSession();
  14.             transaction = session.beginTransaction();
  15.             session.save(user);
  16.             transaction.commit();
  17.         } catch (Exception e) {
  18.             e.printStackTrace();
  19.             if(transaction!=null) {
  20.                 transaction.rollback();
  21.             }
  22.             return 0;
  23.         }
  24.         return 1;
  25.     }
  26.  
  27.     @Override
  28.     public User getUser(User user) {
  29.         SessionFactory sessionFactory = null;
  30.         Session session = null;
  31.         Transaction transaction =null;
  32.         User iUser = null;
  33.         try {
  34.  
  35.             sessionFactory = HibernateUtil.getSessionFactory();
  36.             session = sessionFactory.getCurrentSession();
  37.             transaction = session.beginTransaction();
  38.             Query<User> query = session.createQuery("from User u where u.username=:username and u.password=:password ");
  39.             query.setParameter("username", user.getUsername());
  40.             query.setParameter("password", user.getPassword());
  41.             List<User> uList = query.list();
  42.             if (uList.size()==1) {
  43.                 iUser = uList.get(0);
  44.             }
  45.             transaction.commit();
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.             if(transaction!=null) {
  49.                 transaction.rollback();
  50.             }
  51.         }
  52.         return iUser;
  53.     }
  54.  
  55.     @Override
  56.     public User updateUser(File icon, String extensions, User iUser, User user) {
  57.         user.setUserID(iUser.getUserID());
  58.         user.setPassword(iUser.getPassword());
  59.         SessionFactory sessionFactory = null;
  60.         Session session = null;
  61.         Transaction transaction =null;
  62.         if (extensions!=null) {
  63.             String iconPath = UploadUtil.saveFile(icon, extensions, iUser.getUserID());
  64.             user.setIcon(iconPath);
  65.         }
  66.  
  67.         try {
  68.             sessionFactory = HibernateUtil.getSessionFactory();
  69.             session = sessionFactory.getCurrentSession();
  70.             transaction = session.beginTransaction();
  71.             session.update(user);
  72.             user = session.get(User.class, iUser.getUserID());
  73.             transaction.commit();
  74.  
  75.         } catch (Exception e) {
  76.             e.printStackTrace();
  77.             if(transaction!=null) {
  78.                 transaction.rollback();
  79.             }
  80.         }
  81.         return user;
  82.     }
  83.  
  84.     @Override
  85.     public User queryUserByID(User iUser) {
  86.         SessionFactory sessionFactory = null;
  87.         Session session = null;
  88.         Transaction transaction =null;
  89.         try {
  90.             sessionFactory = HibernateUtil.getSessionFactory();
  91.             session = sessionFactory.getCurrentSession();
  92.             transaction = session.beginTransaction();
  93.             iUser = session.get(User.class, iUser.getUserID());
  94.             transaction.commit();
  95.         } catch (Exception e) {
  96.             e.printStackTrace();
  97.             if(transaction!=null) {
  98.                 transaction.rollback();
  99.             }
  100.         }
  101.         return iUser;
  102.     }
  103.  
  104.     public User queryUserByUsername(User iUser) {
  105.         SessionFactory sessionFactory = null;
  106.         Session session = null;
  107.         Transaction transaction =null;
  108.         User user = null;
  109.         try {
  110.             sessionFactory = HibernateUtil.getSessionFactory();
  111.             session = sessionFactory.getCurrentSession();
  112.             transaction = session.beginTransaction();
  113.             Query query = session.createQuery("from User u where u.username=:username");
  114.             query.setParameter("username", iUser.getUsername());
  115.             List<User> uList = query.list();
  116.             if(uList.size()>0)
  117.             user = (User) query.list().get(0);
  118.             transaction.commit();
  119.         } catch (Exception e) {
  120.             e.printStackTrace();
  121.             if(transaction!=null) {
  122.                 transaction.rollback();
  123.             }
  124.         }
  125.         return user;
  126.     }
  127.  
  128. }

视频dao

  1. public class VideoDaoImpl extends AbstractDao implements VideoDao{
  2.  
  3.     @Override
  4.     public Find queryFind(int findID) {
  5.         Session session = null;
  6.         Transaction transaction = null;
  7.         Query<Find> query = null;
  8.         Find find = null;
  9.         try {
  10.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  11.             transaction = session.beginTransaction();
  12.             query = session.createQuery("from Find f where f.ID=:ID");
  13.             query.setParameter("ID", findID);
  14.             find = query.list().get(1);
  15.             transaction.commit();
  16.         } catch (Exception e) {
  17.             e.printStackTrace();
  18.             if(transaction!=null) {
  19.                 transaction.rollback();
  20.             }
  21.         }
  22.         return find;
  23.     }
  24.  
  25.     @Override
  26.     public List<Find> queryFindList() {
  27.         if(findNum()==0) {
  28.             saveFinds();
  29.         }
  30.         Session session = null;
  31.         Transaction transaction = null;
  32.         Query<Find> query = null;
  33.         try {
  34.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  35.             transaction = session.beginTransaction();
  36.             query = session.createQuery("from Find");
  37.             List<Find> finds = query.list();
  38.             transaction.commit();
  39.             return finds;
  40.         }catch (Exception e) {
  41.             e.printStackTrace();
  42.             if(transaction!=null) {
  43.                 transaction.rollback();
  44.             }
  45.         }
  46.         return null;
  47.     }
  48.  
  49.     @Override
  50.     public long findNum() {
  51.         Session session = null;
  52.         Transaction transaction = null;
  53.         Query query = null;
  54.         long num = 0;
  55.         try {
  56.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  57.             transaction = session.beginTransaction();
  58.             query = session.createQuery("select count(*) from Find");
  59.             num = (long)query.uniqueResult();
  60.             transaction.commit();
  61.         }catch (Exception e) {
  62.             e.printStackTrace();
  63.             if(transaction!=null) {
  64.                 transaction.rollback();
  65.             }
  66.         }
  67.         return num;
  68.     }
  69.  
  70.     @Override
  71.     public void saveFinds() {
  72.         Session session = null;
  73.         Transaction transaction = null;
  74.         try {
  75.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  76.             transaction = session.beginTransaction();
  77.             Find find1 = new Find();
  78.             find1.setFind("游戏");
  79.             Find find2 = new Find();
  80.             find2.setFind("音乐");
  81.             Find find3 = new Find();
  82.             find3.setFind("学习");
  83.             session.save(find1);
  84.             session.save(find2);
  85.             session.save(find3);
  86.             transaction.commit();
  87.         }catch (Exception e) {
  88.             e.printStackTrace();
  89.             if(transaction!=null) {
  90.                 transaction.rollback();
  91.             }
  92.         }
  93.     }
  94.  
  95.     @Override
  96.     public Video addVideo(File resource,Video video,int findID, String extensions) {
  97.         Session session = null;
  98.         Transaction transaction = null;
  99.         String videoPath = UploadUtil.saveFile(resource, extensions, video.getUser().getUserID());
  100.         video.setPath(videoPath);
  101.         video.setDate(new Timestamp(new Date().getTime()));
  102.         try {
  103.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  104.             transaction = session.beginTransaction();
  105.             Find find = session.get(Find.class, findID);
  106.             video.setFind(find);
  107.             session.save(video);
  108.             transaction.commit();
  109.             return video;
  110.         }catch (Exception e) {
  111.             e.printStackTrace();
  112.             if(transaction!=null) {
  113.                 transaction.rollback();
  114.             }
  115.         }
  116.  
  117.         return null;
  118.     }
  119.  
  120.     @Override
  121.     public int getVideoID(String path) {
  122.         Session session = null;
  123.         Transaction transaction = null;
  124.         Query query = null;
  125.         int videoID = 0;
  126.         try {
  127.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  128.             transaction = session.beginTransaction();
  129.             query = session.createQuery("select v.videoID from Video v where v.path=:path");
  130.             query.setParameter("path", path);
  131.             videoID = (int) query.uniqueResult();
  132.             transaction.commit();
  133.         }catch (Exception e) {
  134.             e.printStackTrace();
  135.             if(transaction!=null) {
  136.                 transaction.rollback();
  137.             }
  138.         }
  139.         return videoID;
  140.     }
  141.  
  142.     @Override
  143.     public List<VideoView> getVideos(String type) {
  144.         List<VideoView> videoViews = new ArrayList<>();
  145.         Session session = null;
  146.         Transaction transaction = null;
  147.         Query query = null;
  148.         try {
  149.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  150.             transaction = session.beginTransaction();
  151.             String hql = "from Video v order by videoID desc";
  152.             query = session.createQuery(hql);
  153.             List<Video> videos = query.list();
  154.             for(Video video :videos) {
  155.                 VideoView videoView = new VideoView();
  156.  
  157.                 videoView.setVideo(video);
  158.  
  159.                 videoView.setUser(video.getUser());
  160.  
  161.                 videoView.setFind(video.getFind());
  162.                 //videoView.setPraiseNum(praiseDao.getPraiseNum(video.getVideoID()));
  163.                 videoView.setPraiseNum(video.getPraises().size());
  164.                 //videoView.setPostNum(postDao.getPostNum(video.getVideoID()));
  165.                 videoView.setPostNum(video.getPosts().size());
  166.                 System.out.println(videoView);
  167.                 videoViews.add(videoView);
  168.             }
  169.             transaction.commit();
  170.         } catch (Exception e) {
  171.             e.printStackTrace();
  172.             if(transaction!=null) {
  173.                 transaction.rollback();
  174.             }
  175.         }
  176.         return videoViews;
  177.     }
  178.  
  179.     @Override
  180.     public VideoView queryVideoView(int videoID) {
  181.         Session session = null;
  182.         Transaction transaction = null;
  183.         Query query = null;
  184.         VideoView videoView = new VideoView();
  185.         try {
  186.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  187.             transaction = session.beginTransaction();
  188.             Video video = session.get(Video.class,videoID);
  189.             video.setViewNum(video.getViewNum()+1);
  190.             User user = video.getUser();
  191.             Find find = video.getFind();
  192.             videoView.setFind(find);
  193.  
  194.             videoView.setPostNum(video.getPosts().size());
  195.  
  196.             videoView.setPraiseNum(video.getPraises().size());
  197.             videoView.setUser(user);
  198.             videoView.setVideo(video);
  199.             System.out.println(videoView);
  200.             transaction.commit();
  201.             return videoView;
  202.         } catch (Exception e) {
  203.             e.printStackTrace();
  204.             if(transaction!=null) {
  205.                 transaction.rollback();
  206.             }
  207.         }
  208.         return null;
  209.  
  210.     }
  211.  
  212.     @Override
  213.     public List<VideoView> getVideoViewsByUserID(int userID) {
  214.         List<VideoView> videoViews = new ArrayList<>();
  215.         Session session = null;
  216.         Transaction transaction = null;
  217.         Query query = null;
  218.         try {
  219.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  220.             transaction = session.beginTransaction();
  221.             User user = session.get(User.class, userID);
  222.             query = session.createQuery("from Video where userID=? order by videoID desc");
  223.             query.setParameter(0, user.getUserID());
  224.             List<Video> videos = query.list();
  225.             for(Video video :videos) {
  226.                 VideoView videoView = new VideoView();
  227.                 videoView.setVideo(video);
  228.                 videoView.setUser(user);
  229.                 videoView.setFind(video.getFind());
  230.                 videoView.setPraiseNum(video.getPraises().size());
  231.                 videoView.setPostNum(video.getPosts().size());
  232.                 System.out.println(videoView);
  233.                 videoViews.add(videoView);
  234.             }
  235.             transaction.commit();
  236.         } catch (Exception e) {
  237.             e.printStackTrace();
  238.             if(transaction!=null) {
  239.                 transaction.rollback();
  240.             }
  241.         }
  242.         return videoViews;
  243.     }
  244.  
  245.     @Override
  246.     public int deleteVideo(int videoID, int userID) {
  247.         Session session = null;
  248.         Transaction transaction = null;
  249.         Query query = null;
  250.         try {
  251.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  252.             transaction = session.beginTransaction();
  253.             String hql = "from Video v where videoID=? and userID=?";
  254.             query = session.createQuery(hql);
  255.             query.setParameter(0, videoID);
  256.             query.setParameter(1, userID);
  257.             //query.executeUpdate();
  258.             Video video = (Video) query.list().get(0);
  259.             session.delete(video);
  260.             transaction.commit();
  261.             return 1;
  262.         } catch (Exception e) {
  263.             e.printStackTrace();
  264.             if(transaction!=null) {
  265.                 transaction.rollback();
  266.             }
  267.         }
  268.         return 0;
  269.     }
  270.  
  271. }

PraiseDao

  1. public class PraiseDaoImpl extends AbstractDao implements PraiseDao{
  2.  
  3.     @Override
  4.     public int addPraise(Praise praise,int videoID) {
  5.         Session session = null;
  6.         Transaction transaction = null;
  7.         try {
  8.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  9.             transaction = session.beginTransaction();
  10.             Video video = session.get(Video.class, videoID);
  11.             praise.setVideo(video);
  12.             session.save(praise);
  13.             transaction.commit();
  14.             return 1;
  15.         } catch (Exception e) {
  16.             e.printStackTrace();
  17.             if(transaction!=null) {
  18.                 transaction.rollback();
  19.             }
  20.         }
  21.         return 0;
  22.     }
  23.  
  24.     @Override
  25.     public int queryPraise(User iUser, VideoView videoView) {
  26.         Session session = null;
  27.         Transaction transaction = null;
  28.         try {
  29.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  30.             transaction = session.beginTransaction();
  31.             String hql = "from Praise where userID=? and videoID=?";
  32.             Query<Praise> query = session.createQuery(hql);
  33.             query.setParameter(0, iUser.getUserID());
  34.             query.setParameter(1, videoView.getVideo().getVideoID());
  35.             List<Praise> praises = query.list();
  36.             transaction.commit();
  37.             return praises.size();
  38.         } catch (Exception e) {
  39.             // TODO: handle exception
  40.         }
  41.         return 0;
  42.  
  43.     }
  44.  
  45. }

PostDao

  1. public class PostDaoImpl extends AbstractDao implements PostDao {
  2.  
  3.     @Override
  4.     public List<PostView> getPostViews(int videoID) {
  5.         List<PostView> postViews = new ArrayList<>();
  6.         Session session = null;
  7.         Transaction transaction = null;
  8.         try {
  9.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  10.             transaction = session.beginTransaction();
  11.             //Video video = session.get(Video.class, videoID);
  12.             Query<Post> query = session.createQuery("from Post where videoID=? order by postID desc");
  13.             query.setParameter(0, videoID);
  14.             List<Post> posts = query.list();
  15.             for(Post post:posts) {
  16.                 PostView postView = new PostView();
  17.                 User user = post.getUser();
  18.                 postView.setPost(post);
  19.                 postView.setUser(user);
  20.                 System.out.println(postView);
  21.                 postViews.add(postView);
  22.             }
  23.             transaction.commit();
  24.  
  25.         } catch (Exception e) {
  26.             e.printStackTrace();
  27.             if(transaction!=null) {
  28.                 transaction.rollback();
  29.             }
  30.         }
  31.         return postViews;
  32.  
  33.     }
  34.  
  35.     @Override
  36.     public int addPost(int videoID, int userID, String content) {
  37.         Session session = null;
  38.         Transaction transaction = null;
  39.         Post post = new Post();
  40.         post.setDate(new Timestamp(new Date().getTime()));
  41.         post.setContent(content);
  42.         try {
  43.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  44.             transaction = session.beginTransaction();
  45.             Video video = session.get(Video.class, videoID);
  46.             User user = session.get(User.class, userID);
  47.             post.setVideo(video);
  48.             post.setUser(user);
  49.             session.save(post);
  50.             transaction.commit();
  51.             return 1;
  52.         } catch (Exception e) {
  53.             e.printStackTrace();
  54.             if(transaction!=null) {
  55.                 transaction.rollback();
  56.             }
  57.         }
  58.         return 0;
  59.     }}

FollowDao

  1. public class FollowDaoImpl extends AbstractDao implements FollowDao{
  2.     @Override
  3.     public List<FollowView> queryFollows(int userID) {
  4.         List<FollowView> followViews = new ArrayList<>();
  5.         Session session = null;
  6.         Transaction transaction = null;
  7.         try {
  8.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  9.             transaction = session.beginTransaction();
  10.             String hql = "from Follow f where f.user1=:user1";
  11.             User user = session.get(User.class, userID);
  12.             Query<Follow> query = session.createQuery(hql);
  13.             query.setParameter("user1",user );
  14.             List<Follow> follows  = query.list();
  15.             for(Follow follow :follows) {
  16.                 FollowView followView = new FollowView();
  17.                 followView.setFollow(follow);
  18.                 User user2 = follow.getUser2();
  19.                 followView.setUser(user2);
  20.                 System.out.println(followView);
  21.                 followViews.add(followView);
  22.             }
  23.             transaction.commit();
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.             if(transaction!=null) {
  27.                 transaction.rollback();
  28.             }
  29.         }
  30.         return followViews;
  31.  
  32.     }
  33.     @Override
  34.     public int deleteFollow(User iUser, int userID2) {
  35.         Session session = null;
  36.         Transaction transaction = null;
  37.         try {
  38.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  39.             transaction = session.beginTransaction();
  40.             User user1 = session.get(User.class, iUser.getUserID());
  41.             User user2 = session.get(User.class, userID2);
  42.             String hql = "from Follow f where f.user1=:user1 AND f.user2=:user2";
  43.             Query<Follow> query = session.createQuery(hql);
  44.             query.setParameter("user1",user1);
  45.             query.setParameter("user2", user2);
  46.             Follow follow = query.list().get(0);
  47.             session.delete(follow);
  48.             transaction.commit();
  49.             return 1;
  50.         } catch (Exception e) {
  51.             e.printStackTrace();
  52.             if(transaction!=null) {
  53.                 transaction.rollback();
  54.             }
  55.         }
  56.         return 0;
  57.     }
  58.     @Override
  59.     public long queryFollowedNum(int userID) {
  60.         long num = 0;
  61.         Session session = null;
  62.         Transaction transaction = null;
  63.         try {
  64.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  65.             transaction = session.beginTransaction();
  66.             User user = session.get(User.class, userID);
  67.             String hql ="select count(*) from Follow f where f.user2=:user2";
  68.             Query query = session.createQuery(hql);
  69.             query.setParameter("user2", user);
  70.             num =(long) query.uniqueResult();
  71.             transaction.commit();
  72.         } catch (Exception e) {
  73.             e.printStackTrace();
  74.             if(transaction!=null) {
  75.                 transaction.rollback();
  76.             }
  77.         }
  78.         return num;
  79.     }
  80.     @Override
  81.     public long queryFollowNum(int userID) {
  82.         long num = 0;
  83.         Session session = null;
  84.         Transaction transaction = null;
  85.         try {
  86.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  87.             transaction = session.beginTransaction();
  88.             User user = session.get(User.class, userID);
  89.             String hql ="select count(*) from Follow f where f.user1=:user1";
  90.             Query query = session.createQuery(hql);
  91.             query.setParameter("user1", user);
  92.             num = (long) query.uniqueResult();
  93.             transaction.commit();
  94.         } catch (Exception e) {
  95.             e.printStackTrace();
  96.             if(transaction!=null) {
  97.                 transaction.rollback();
  98.             }
  99.         }
  100.         return num;
  101.     }
  102.     @Override
  103.     public long getFollow(int userID1, int userID2) {
  104.         long num = 0;
  105.         Session session = null;
  106.         Transaction transaction = null;
  107.         try {
  108.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  109.             transaction = session.beginTransaction();
  110.             User user1 = session.get(User.class, userID1);
  111.             User user2 = session.get(User.class, userID2);
  112.             String hql ="select count(*) from Follow f where f.user1=:user1 and f.user2=:user2";
  113.             Query query = session.createQuery(hql);
  114.             query.setParameter("user1", user1);
  115.             query.setParameter("user2", user2);
  116.             num = (long) query.uniqueResult();
  117.             transaction.commit();
  118.         } catch (Exception e) {
  119.             e.printStackTrace();
  120.             if(transaction!=null) {
  121.                 transaction.rollback();
  122.             }
  123.         }
  124.         return num;
  125.  
  126.     }
  127.     @Override
  128.     public int addFollow(int userID1, int userID2) {
  129.         int num = 0;
  130.         Session session = null;
  131.         Transaction transaction = null;
  132.         Follow follow = new Follow();
  133.         try {
  134.             session = HibernateUtil.getSessionFactory().getCurrentSession();
  135.             transaction = session.beginTransaction();
  136.             User user1 = session.get(User.class, userID1);
  137.             User user2 = session.get(User.class, userID2);
  138.             follow.setUser1(user1);
  139.             follow.setUser2(user2);
  140.             session.save(follow);
  141.             transaction.commit();
  142.         } catch (Exception e) {
  143.             e.printStackTrace();
  144.             if(transaction!=null) {
  145.                 transaction.rollback();
  146.             }
  147.         }
  148.         return num;
  149.     }
  150.  
  151. }

　　　　　

第六次作业 orm整合 接口的更多相关文章

  1. 17秋 软件工程 第六次作业 Beta冲刺 Scrum1

    17秋 软件工程 第六次作业 Beta冲刺 Scrum1 各个成员冲刺期间完成的任务 重新梳理项目架构与当前进展,并且对我们的Alpha版本项目进行完整测试,将测试过程中发现的问题列入Github i ...

  2. 17秋 软件工程 第六次作业 Beta冲刺 Scrum2

    17秋 软件工程 第六次作业 Beta冲刺 Scrum2 我们组转会成员:杰麟: 我们组新成员:宏庆. 各个成员冲刺期间完成的任务 世强:完成分页功能的演示: 陈翔:完成超级管理员后端login模块: ...

  3. 17秋 软件工程 第六次作业 Beta冲刺 Scrum3

    17秋 软件工程 第六次作业 Beta冲刺 Scrum3 各个成员冲刺期间完成的任务 世强:完成手势签到模块,重构活动详情页面: 陈翔:完善超级管理员后端login模块,完成logout模块: 树民: ...

  4. 17秋 软件工程 第六次作业 Beta冲刺 Scrum4

    17秋 软件工程 第六次作业 Beta冲刺 Scrum4 各个成员冲刺期间完成的任务 世强:完成APP用户签到模块.群发短信模块前端界面: 陈翔:恢复Github项目,完成Scrum博客: 树民:和超 ...

  5. C++第六次作业

    前言 拿到作业的时候,整个人都不好了,虽然之前和同学说以后一起写游戏,画界面,然而现在的自己对界面的知识一窍不通,虽然同学分享了一些资料,但是通过这次作业,发现自己火候还是不够-- 问题描述及仓库地址 ...

  6. Week06《Java程序设计》第六次作业总结

    Week06<Java程序设计>第六次作业总结 1. 本周学习总结 1.1 面向对象学习暂告一段落,请使用思维导图,以封装.继承.多态为核心概念画一张思维导图或相关笔记,对面向对象思想进行 ...

  7. 201621123080《java程序设计》第六周作业总结

    201621123080<java程序设计>第六周作业总结 1. 本周学习总结 2. 书面作业 clone方法 1.1 在test1包中编写Employee类,在test2包中新建一个Te ...

  8. 【西北师大-2108Java】第六次作业成绩汇总

    [西北师大-2108Java]第六次作业成绩汇总 作业题目 面向对象程序设计(JAVA) 第8周学习指导及要求 实验目的与要求 (1)掌握接口定义方法: (2)掌握实现接口类的定义要求: (3)掌握实 ...

  9. 《ABCD组》第六次作业：团队项目系统设计改进与详细设计

    <ABCD组>第六次作业:团队项目系统设计改进与详细设计 项目 内容 这个作业属于哪个课程 http://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 ht ...

随机推荐

  1. tcp/ip通信中ip头部结构iph->check校验计算

    通过raw socket修改通信数据后,可通过该函数重新校验计算iph->check值 在http://www.cnblogs.com/dpf-10/p/7899237.html查看实际调用 s ...

  2. JavaScript的3种继承方式

    JavaScript的继承方式有多种,这里列举3种,分别是原型继承.类继承以及混合继承. 1.原型继承 优点:既继承了父类的模板,又继承了父类的原型对象: 缺点:不是子类实例传参,而是需要通过父类实例 ...

  3. .5-浅析webpack源码之入口函数

    从convert-argv出来后,目前进度在这: yargs.parse(process.argv.slice(2), (err, argv, output) => { // ... // 从这 ...

  4. Net is as typeof 运行运算符详解

    概述 在了解运行运算符的前提我们需要了解什么是RTTI ,在任何一门面向对象的语言中,都有RTTI这个概念(即 运行时). RTTI(Run-Time Type Identification),通过运 ...

  5. Ubuntu安装完成后设置root密码

    安装完ubuntu后没有默认的root密码,如果要设置root密码需要进行如下步骤: 1 sudo passwd 2 连续输入两次新密码

  6. HDU3416(KB11-O spfa+最大流)

    Marriage Match IV Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others ...

  7. python学习之老男孩python全栈第九期_day009之文件操作总结

    # 文件处理# 打开文件# open('路径','打开方式', '指定编码方式')# 打开方式:r w a 可读可写:r+ 可写可读:w+ 可追加可读:a+ b# r+ :打开文件直接写,和读完再写 ...

  8. Vue 爬坑之路（十）—— Vue2.5 + Typescript 构建项目

    Typescript 在前端圈已经逐渐普及,Vue 2.5.0 改进了类型声明,使得对 TypeScript 更加友好 不过要想在项目中直接使用 TypeScript  仍然需要对项目进行一些改造 P ...

  9. PHP中Cookie的使用---添加/更新/删除/获取Cookie 及 自动填写该用户的用户名和密码和判断是否第一次登陆

    PHP中Cookie的使用---添加/更新/删除/获取Cookie 及 自动填写该用户的用户名和密码和判断是否第一次登陆  什么是cookie 服务器在客户端保存用户的信息,比如登录名,密码等 这些数 ...

  10. CSS隐藏多余的文字

    效果: <p><strong>商品名称:</strong>新鲜现摘云南绥江半边红李子甜脆脱骨李6斤当季绿色有机水果包邮</p></div> ...