İlkbaharda hazırda bekletme, myqsl veritabanından tasarruf etmiyor

Question

Hazırda bekleme ilkesiyle ilgili bir sorunum var. Orada herhangi bir hata değil ama hazırda beklet DB bilgileri kaydetmek zorunda kaldığında bir mesaj

hazırda başlatmak:? insert içine Çalışanlar (yaş, isim, maaş) değerleri (, ?)

Ben defalarca debug sadece benim memuru-servlet.xml, yapılandırmak için bir hibernate.cfg.xml Fila kullanmayan Im ve ben fi edemem nd sorun ... i

konsol mesajları

22 Mart 2016 15:35:33 org.vacajose.controller.EmployeeController createEmployee BİLGİ burada kod parçasını ve konsol mesajları takmak : Çalışan yaratmak. Veri: Çalışan {id = 0, name = 'null', yaş = 0, maaş = 0.0} mar 22, 2016 3:35:48 PM org.vacajose.controller.EmployeeController saveEmployee BİLGİ: Çalışan kaydetme. Veri: Çalışan {id = 0, adı = 'Jose', yaş = 12, maaş = 123.0} hazırda: (?,?,) uç içine Çalışan (yaş, isim, maaş) değerleri mar 22, 2016 3:35:48 PM org.vacajose.controller.EmployeeController getAllEmployees INFO: Tüm Çalışanları Başlarken. Hazırda: Gördüğünüz gibi salary4_0_ Çalışanlar

employee0_ olarak id1_0_ olarak employee0_.id, age2_0_ olarak employee0_.age, name3_0_ olarak employee0_.name, employee0_.salary seçmek, bu bilgileri okur formu ancak ekleme sorgu yapmak zorunda olduğunda veriler mevcut değil ... lütfen sorunun ne olduğunu bilmiyorum.

MVC-memuru-servlet.xml

<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" 
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context" 
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd 
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd 
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 

<!-- Specifying base package of the Components like Controller, Service, 
DAO --> 
<context:component-scan 
base-package="org.vacajose" /> 

<!-- Getting Database properties --> 
<context:property-placeholder location="classpath:application.properties" /> 

<mvc:annotation-driven /> 

<!-- Specifying the Resource location to load JS, CSS, Images etc --> 
<mvc:resources mapping="/resources/**" location="/resources/" /> 

<!-- View Resolver --> 
<bean 
class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
<property name="prefix" value="/WEB-INF/pages/" /> 
<property name="suffix" value=".jsp" /> 
</bean> 

<!-- DataSource --> 
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 
destroy-method="close"> 
<property name="driverClass" value="${database.driverClass}" /> 
<property name="jdbcUrl" value="${database.url}" /> 
<property name="user" value="${database.username}" /> 
<property name="password" value="${database.password}" /> 

<property name="acquireIncrement" value="${connection.acquireIncrement}" /> 
<property name="minPoolSize" value="${connection.minPoolSize}" /> 
<property name="maxPoolSize" value="${connection.maxPoolSize}" /> 
<property name="maxIdleTime" value="${connection.maxIdleTime}" /> 
</bean> 

<!-- Hibernate SessionFactory --> 
<bean id="sessionFactory" 
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> 
<property name="dataSource" ref="dataSource"></property> 
<property name="hibernateProperties"> 
<props> 
<prop key="hibernate.dialect">${hibernate.dialect}</prop> 
<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop> 
<prop key="hibernate.format_sql">${hibernate.format_sql}</prop> 
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop> 
<prop key="hibernate.connection.autocommit">${hibernate.connection.autocommit}</prop> 

</props> 
</property> 
<property name="packagesToScan" value="org.vacajose.entity"></property> 
</bean> 

<!-- Transaction --> 
<bean id="transactionManager" 
class="org.springframework.orm.hibernate4.HibernateTransactionManager"> 
<property name="sessionFactory" ref="sessionFactory" /> 
</bean> 

<tx:annotation-driven transaction-manager="transactionManager" /> 
</beans> 

EmployeeControler.java

package org.vacajose.controller; 

import java.util.List; 

import org.jboss.logging.Logger; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Controller; 
import org.springframework.web.bind.annotation.ModelAttribute; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RequestParam; 
import org.springframework.web.servlet.ModelAndView; 
import org.vacajose.entity.Employee; 
import org.vacajose.service.EmployeeService; 

/** 
* @author Jose Luis 
* @version 1.0 
*/ 
@Controller 
public class EmployeeController { 

    private static final Logger logger = Logger.getLogger(EmployeeController.class); 

    public EmployeeController() { 
     System.out.println("EmployeeController()"); 
    } 

    @Autowired 
    private EmployeeService employeeService; 

    @RequestMapping("createEmployee") 
    public ModelAndView createEmployee(@ModelAttribute Employee employee) { 
     logger.info("Creating Employee. Data: " + employee); 
     return new ModelAndView("employeeForm", "employee", employee); 
    } 

    @RequestMapping("editEmployee") 
    public ModelAndView editEmployee(@RequestParam long id, @ModelAttribute Employee employee) { 
     logger.info("Updating the Employee for the Id " + id); 
     employee = employeeService.getEmployee(id); 
     return new ModelAndView("employeeForm", "employeeObject", employee); 
    } 

    @RequestMapping("saveEmployee") 
    public ModelAndView saveEmployee(@ModelAttribute Employee employee) { 
     logger.info("Saving the Employee. Data : " + employee); 
     if (employee.getId() == 0) { // if employee id is 0 then creating the 
             // employee other updating the employee 
      employeeService.createEmployee(employee); 
     } else { 
      employeeService.updateEmployee(employee); 
     } 
     return new ModelAndView("redirect:getAllEmployees"); 
    } 

    @RequestMapping("deleteEmployee") 
    public ModelAndView deleteEmployee(@RequestParam long id) { 
     logger.info("Deleting the Employee. Id : " + id); 
     employeeService.deleteEmployee(id); 
     return new ModelAndView("redirect:getAllEmployees"); 
    } 

    @RequestMapping("getAllEmployees") 
    public ModelAndView getAllEmployees() { 
     logger.info("Getting the all Employees."); 
     List<Employee> employeeList = employeeService.getAllEmployees(); 
     return new ModelAndView("employeeList", "employeeList", employeeList); 
    } 

    @RequestMapping("searchEmployee") 
    public ModelAndView searchEmployee(@RequestParam("searchName") String searchName) { 
     logger.info("Searching the Employee. Employee Names: " + searchName); 
     List<Employee> employeeList = employeeService.getAllEmployees(searchName); 
     return new ModelAndView("employeeList", "employeeList", employeeList); 
    } 
} 

EmployeeDAOImpl.java

package org.vacajose.dao; 

import org.vacajose.dao.EmployeeDAO; 
import org.vacajose.entity.Employee; 
import org.vacajose.util.HibernateUtil; 

import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Repository; 

import java.math.BigInteger; 
import java.util.ArrayList; 
import java.util.List; 

/** 
* @author Jose Luis  
* @version 1.0 
*/ 

@Repository 
public class EmployeeDAOImpl implements EmployeeDAO { 

    public EmployeeDAOImpl() { 
     System.out.println("EmployeeDAOImpl"); 
    } 

    @Autowired 
    private HibernateUtil hibernateUtil; 

    @Override 
    public long createEmployee(Employee employee) { 
     return (Long) hibernateUtil.create(employee); 
    } 

    @Override 
    public Employee updateEmployee(Employee employee) { 
     return hibernateUtil.update(employee); 
    } 

    @Override 
    public void deleteEmployee(long id) { 
     Employee employee = new Employee(); 
     employee.setId(id); 
     hibernateUtil.delete(employee); 
    } 

    @Override 
    public List<Employee> getAllEmployees() { 
     return hibernateUtil.fetchAll(Employee.class); 
    } 

    @Override 
    public Employee getEmployee(long id) { 
     return hibernateUtil.fetchById(id, Employee.class); 
    } 

    @SuppressWarnings("unchecked") 
    @Override 
    public List<Employee> getAllEmployees(String employeeName) { 
     String query = "SELECT e.* FROM Employees e WHERE e.name like '%" + employeeName + "%'"; 
     List<Object[]> employeeObjects = hibernateUtil.fetchAll(query); 
     List<Employee> employees = new ArrayList<Employee>(); 
     for (Object[] employeeObject : employeeObjects) { 
      Employee employee = new Employee(); 
      long id = ((BigInteger) employeeObject[0]).longValue(); 
      int age = (int) employeeObject[1]; 
      String name = (String) employeeObject[2]; 
      float salary = (float) employeeObject[3]; 
      employee.setId(id); 
      employee.setName(name); 
      employee.setAge(age); 
      employee.setSalary(salary); 
      employees.add(employee); 
     } 
     System.out.println(employees); 
     return employees; 
    } 
} 

hibernateutil.java

package org.vacajose.util; 

import java.io.Serializable; 
import java.util.List; 

import org.hibernate.SessionFactory; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Repository; 

/** 
* @author Jose Vaca 
* @version 1.0 
*/ 
@Repository 
public class HibernateUtil { 

    @Autowired 
    private SessionFactory sessionFactory; 

    public <T> Serializable create(final T entity) { 
     return sessionFactory.getCurrentSession().save(entity); 
    } 

    public <T> T update(final T entity) { 
     sessionFactory.getCurrentSession().update(entity); 
     return entity; 
    } 

    public <T> void delete(final T entity) { 
     sessionFactory.getCurrentSession().delete(entity); 
    } 

    public <T> void delete(Serializable id, Class<T> entityClass) { 
     T entity = fetchById(id, entityClass); 
     delete(entity); 
    } 

    @SuppressWarnings("unchecked") 
    public <T> List<T> fetchAll(Class<T> entityClass) { 
     return sessionFactory.getCurrentSession().createQuery(" FROM " + entityClass.getName()).list(); 
    } 

    @SuppressWarnings("rawtypes") 
    public <T> List fetchAll(String query) { 
     return sessionFactory.getCurrentSession().createSQLQuery(query).list(); 
    } 

    @SuppressWarnings("unchecked") 
    public <T> T fetchById(Serializable id, Class<T> entityClass) { 
     return (T) sessionFactory.getCurrentSession().get(entityClass, id); 
    } 
} 

Bazı bilgilere gereksinim duyuyorsanız lütfen bizi bilgilendirin ...

Answer 1

İşlemin yapılmadığı anlaşılıyor, her denetleyici yöntemine @Transactional ekleyin.