Hibernate没有给我最近保存的记录

我正在使用Struts+Hibernate，我已经创建了一个应用程序，可以在其中保存电影记录并显示它们或搜索电影。但我面临一个奇怪的问题。当我保存新的电影唱片时，它正在保存唱片。之后，当我选择电影列表以显示电影表中的所有记录时。在第一次尝试时，它不会显示新更新的记录。当我第二次单击“显示电影列表”时，它肯定会显示新行。为什么hibernate没有一次性提供最近插入的行

这是我添加电影的控制器

public class AddMovieAction extends Action {

    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        SessionFactory factory = (SessionFactory) getServlet().getServletContext().getAttribute("factory");
        AddMovieForm formFilled = (AddMovieForm) form;
        MoviesDaoImpl moviesDaoImpl = new MoviesDaoImpl(factory);

        ActionMessages actionMessages = new ActionMessages();
        if (moviesDaoImpl.addMovie(formFilled.getMovieName(), formFilled.getMovieReleaseYear(),
                formFilled.getMovieLeadActor(), formFilled.getMovieHouseName())) {
            actionMessages.add("success", new ActionMessage("message.success"));
        }
        saveMessages(request, actionMessages);
        return mapping.findForward("samepage");
    }
}

这是我的显示控制器

public class DisplayMoviesAction extends Action {

    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        SessionFactory factory = (SessionFactory) getServlet().getServletContext().getAttribute("factory");
        MoviesDaoImpl moviesDaoImpl = new MoviesDaoImpl(factory);
        List<Movie> movies = moviesDaoImpl.getAllMovies();
        request.setAttribute("movies", movies);
        return mapping.findForward("list");
    }
}

public类DisplayMoviesAction扩展了动作{
@凌驾
公共ActionForward执行（ActionMapping映射、ActionForm表单、HttpServletRequest请求、，
HttpServletResponse）引发异常{
SessionFactory工厂=（SessionFactory）getServlet（）.getServletContext（）.getAttribute（“工厂”）；
MoviesDaoImpl MoviesDaoImpl=新MoviesDaoImpl（工厂）；
List movies=moviesDaoImpl.getAllMovies（）；
setAttribute（“电影”，电影）；
返回映射。findForward（“列表”）；
}
}

这是我的电影daoimpl.java

public class MoviesDaoImpl implements MoviesDao {

    private SessionFactory factory;

    public MoviesDaoImpl(SessionFactory factory) {
        this.factory = factory;
    }

    @Override
    public List<Movie> getMovieByName(String name) {
        Session session = factory.openSession();
        session.beginTransaction();
        try {
            String hql = "FROM Movie M WHERE M.movieName like :movieName";
            org.hibernate.Query query = session.createQuery(hql);
            query.setParameter("movieName", "%" + name + "%");
            @SuppressWarnings("unchecked")
            List<Movie> movies = query.list();
            session.getTransaction().commit();
            return movies;
        } catch (HibernateException e) {
            e.printStackTrace();
            return null;
        } finally {
            session.close();
        }
    }

    @Override
    public List<Movie> getAllMovies() {
        Session session = factory.openSession();
        session.beginTransaction();
        @SuppressWarnings("unchecked")
        List<Movie> movies = (List<Movie>) session.createQuery("From Movie").list();
        session.getTransaction().commit();
        session.close();
        return movies;
    }

    @Override
    public boolean addMovie(String movieName, String movieReleaseYear, String movieLeadActor, String movieHouse) {
        Session session = factory.openSession();
        try {
            session.beginTransaction();
            // Check if movie is already exists or not. Why create duplicate rows of same movie
            Movie movie = getExistingMovieByName(movieName);
            if(movie==null){
                movie = new Movie();
            }
            movie.setMovieName(movieName);
            movie.setMovieReleaseYear(movieReleaseYear);
            // Check if actor already exists or not. Why create duplicate rows of same actor
            Actor actor = getExistingActor(movieLeadActor);
            if(actor!=null){
                movie.setLeadActor(actor);
            }else{
                actor = new Actor();
                actor.setActorName(movieLeadActor);
                movie.setLeadActor(actor);
            }
            // Check if Movie House already exists or not. Why create duplicate rows of same Movie House
            MoviesHouse moviesHouse = getMovieHouseId(movieHouse);
            if (moviesHouse != null) {
                System.out.println("MovieHouse Exists no need to create new record");
                movie.setMovieHouse(moviesHouse);
            } else {
                moviesHouse = new MoviesHouse();
                moviesHouse.setMovieHouseName(movieHouse);
                movie.setMovieHouse(moviesHouse);
                System.out.println("create movie house");
            }
            session.saveOrUpdate(movie);
            session.saveOrUpdate(actor);
            session.saveOrUpdate(moviesHouse);
            session.getTransaction().commit();

        } catch (HibernateException e) {
            e.printStackTrace();
            return false;
        } finally {
            session.close();
        }
        /*Session session1 = factory.openSession();
        session1.beginTransaction();
        @SuppressWarnings("unchecked")
        List<Movie> movies = session1.createQuery("From Movie").list(); 
        for(Movie m:movies){
            System.out.println(m);
        }
        session1.getTransaction().commit();
        session1.close();*/
        return true;
    }

    public MoviesHouse getMovieHouseId(String movieHouseName) {
        Session session = factory.openSession();
        session.beginTransaction();
        Criteria crit = session.createCriteria(MoviesHouse.class);
        crit.add(Restrictions.eq("movieHouseName", movieHouseName));
        @SuppressWarnings("unchecked")
        List<MoviesHouse> results = crit.list();
        MoviesHouse moviesHouse = null;
        try {
            moviesHouse = (MoviesHouse) results.get(0);
            session.getTransaction().commit();
            return moviesHouse;
        } catch (Exception e) {
            return moviesHouse;
        } finally {
            session.close();
        }
    }
    public Actor getExistingActor(String actorName){
        Session session = factory.openSession();
        session.beginTransaction();
        Criteria crit = session.createCriteria(Actor.class);
        crit.add(Restrictions.eq("actorName", actorName));
        @SuppressWarnings("unchecked")
        List<Actor> results = crit.list();
        Actor actor = null;
        try {
            actor = (Actor) results.get(0);
            session.getTransaction().commit();
            return actor;
        } catch (Exception e) {
            return actor;
        } finally {
            session.close();
        }
    }

    public Movie getExistingMovieByName(String movieName){
        Session session = factory.openSession();
        session.beginTransaction();
        Criteria crit = session.createCriteria(Movie.class);
        crit.add(Restrictions.eq("movieName", movieName));
        @SuppressWarnings("unchecked")
        List<Movie> results = crit.list();
        Movie movie = null;
        try {
            movie = (Movie) results.get(0);
            session.getTransaction().commit();
            return movie;
        } catch (Exception e) {
            return movie;
        } finally {
            session.close();
        }
    }
}

公共类MoviesDaoImpl实现MoviesDao{
私营工厂；
公共电影DAOIMPL（会话工厂）{
这个工厂=工厂；
}
@凌驾
公共列表getMovieByName（字符串名称）{
Session Session=factory.openSession（）；
session.beginTransaction（）；
试一试{
String hql=“FROM Movie M，其中M.movieName like:movieName”；
org.hibernate.Query Query=session.createQuery（hql）；
query.setParameter（“movieName”，“%%”+name+“%”）；
@抑制警告（“未选中”）
List movies=query.List（）；
session.getTransaction（）.commit（）；
返回电影；
}捕获（休眠异常e）{
e、 printStackTrace（）；
返回null；
}最后{
session.close（）；
}
}
@凌驾
公共列表getAllMovies（）{
Session Session=factory.openSession（）；
session.beginTransaction（）；
@抑制警告（“未选中”）
List movies=（List）session.createQuery（“From Movie”）.List（）；
session.getTransaction（）.commit（）；
session.close（）；
返回电影；
}
@凌驾
公共布尔addMovie（字符串movieName、字符串movieReleaseYear、字符串movieeadactor、字符串movieHouse）{
Session Session=factory.openSession（）；
试一试{
session.beginTransaction（）；
//检查电影是否已经存在。为什么要创建同一电影的重复行
电影=getExistingMovieByName（movieName）；
如果（电影==null）{
电影=新电影（）；
}
movie.setMovieName（movieName）；
movier.setMovieReleaseYear（movieReleaseYear）；
//检查参与者是否已经存在。为什么要创建同一参与者的重复行
演员演员=getExistingActor（MovieReadActor）；
if（actor！=null）{
电影。主角（演员）；
}否则{
actor=新actor（）；
actor.setActorName（movieLeadActor）；
电影。主角（演员）；
}
//检查影楼是否已经存在。为什么要创建同一影楼的重复行
MoviesHouse MoviesHouse=getMovieHouseId（movieHouse）；
if（moviesHouse！=null）{
System.out.println（“MovieHouse存在，无需创建新记录”）；
movie.setMovieHouse（moviesHouse）；
}否则{
moviesHouse=新建moviesHouse（）；
movieHouse.setmoviehouse名称（movieHouse）；
movie.setMovieHouse（moviesHouse）；
System.out.println（“创建电影屋”）；
}
session.saveOrUpdate（电影）；
session.saveOrUpdate（actor）；
会议.保存或更新（电影之家）；
session.getTransaction（）.commit（）；
}捕获（休眠异常e）{
e、 printStackTrace（）；
返回false；
}最后{
session.close（）；
}
/*会话session1=factory.openSession（）；
会话1.beginTransaction（）；
@抑制警告（“未选中”）
List movies=session1.createQuery（“来自电影”）.List（）；
电影（m：电影）{
系统输出打印项次（m）；
}
session1.getTransaction（）.commit（）；
session1.close（）*/
返回true；
}
公共影楼getMovieHouseId（字符串movieHouseName）{
Session Session=factory.openSession（）；
session.beginTransaction（）；
Criteria crit=session.createCriteria（MoviesHouse.class）；
标准添加（限制条件eq（“movieHouseName”，movieHouseName））；
@抑制警告（“未选中”）
列表结果=crit.List（）；
MoviesHouse MoviesHouse=null；
试一试{
moviesHouse=（moviesHouse）结果。获取（0）；
session.getTransaction（）.commit（）；
返回电影院；
}捕获（例外e）{
返回电影院；
}最后{
session.close（）；
}
}
公共参与者getExistingActor（字符串actorName）{
Session Session=factory.openSession（）；
session.beginTransaction（）；
Criteria crit=session.createCriteria（Actor.class）；
标准添加（限制条件（“actorName”，actorName））；
@抑制警告（“未选中”）
列表结果=crit.List（）；
Actor=null；
试一试{
actor=（actor）results.get（0）；
session.getTransaction（）.commit（）；
回归演员；
}捕获（例外e）{
回归演员；
}最后{
session.close（）；