protected void clear() {
UnitOfWork uow = acquireUnitOfWork();
// use alternate way for Symfoware as it doesn't support UpdateAll/DeleteAll on multi-table
// objects (see rfe 298193)
if (!(JUnitTestCase.getServerSession("fieldaccess")).getPlatform().isSymfoware()) {
UpdateAllQuery updateEmployees = new UpdateAllQuery(Employee.class);
updateEmployees.addUpdate("manager", null);
updateEmployees.addUpdate("address", null);
uow.executeQuery(updateEmployees);
uow.executeQuery(new DeleteAllQuery(Employee.class));
} else {
Iterator<Employee> emps = uow.readAllObjects(Employee.class).iterator();
while (emps.hasNext()) {
Employee emp = emps.next();
emp.setManager(null);
emp.setAddress(null);
uow.deleteObject(emp);
}
;
}
UpdateAllQuery updateProjects = new UpdateAllQuery(Project.class);
updateProjects.addUpdate("teamLeader", null);
uow.executeQuery(updateProjects);
uow.executeQuery(new DeleteAllQuery(PhoneNumber.class));
uow.executeQuery(new DeleteAllQuery(Address.class));
uow.executeQuery(new DeleteAllQuery(Project.class));
uow.commit();
dbSessionClearCache();
}
protected void setup() {
// save current null values for later restoration
saveDefaultDefaultNullValues = ConversionManager.getDefaultManager().getDefaultNullValues();
saveDefaultNullValues =
getSession().getLogin().getPlatform().getConversionManager().getDefaultNullValues();
getSession()
.getLogin()
.getPlatform()
.getConversionManager()
.setDefaultNullValues(new Hashtable());
getSession().getLogin().setDefaultNullValue(String.class, "null");
getSession().getLogin().setDefaultNullValue(int.class, new Integer(-1));
// Reinit mappings.
for (DatabaseMapping mapping : getSession().getDescriptor(Address.class).getMappings()) {
if (mapping.isDirectToFieldMapping()) {
mapping.preInitialize(getAbstractSession());
}
}
getAbstractSession().beginTransaction();
employee = new Employee();
employee.setFirstName("Fred");
employee.setLastName("Flintstone");
employee.setSalary(22);
employee.setGender("Male");
Address address = new Address();
address.setCity(null);
employee.setAddress(address);
getAbstractSession().writeObject(employee);
// force the salary to be NULL
getSession()
.executeNonSelectingCall(
new SQLCall("update SALARY set SALARY = null where EMP_ID = " + employee.getId()));
}
@Override
public List<Employee> getAllEmployees() throws SQLException {
// TODO Auto-generated method stub
List<Employee> empList = new ArrayList<Employee>();
String sql = "Select * from employees;";
DbConnection db = new DbConnection();
Connection con = db.getConnection();
PreparedStatement ps = con.prepareStatement(sql);
ResultSet r = ps.executeQuery();
if (r != null) {
while (r.next()) {
Employee e = new Employee();
e.setId(r.getInt("id"));
e.setFull_name(r.getString("full_name"));
e.setGender(r.getString("gender"));
e.setPhone(r.getString("phone"));
e.setAddress(r.getString("address"));
e.setUser_id(r.getInt("dept_id"));
empList.add(e);
}
r.close();
ps.close();
con.close();
}
return empList;
}
public static void main(String[] args) {
AbstractApplicationContext context =
new ClassPathXmlApplicationContext(
"spring-configuration/serialization-spring-configuration.xml");
Employee employee = (Employee) context.getBean("employee");
// Employee employee = new Employee();//I don't need this line any more,
// since I quickly set up a component-scan using Spring to auto wire
// this employee bean for me, this is so cool! I feel so at home with
// Spring dependency injection now! Praise the Lord!a
employee.setName("Steve Sun");
employee.setAge(26);
employee.setAddress("1860 Charmeran Ave, San Jose, USA.");
employee.setSSN(12345678);
employee.setSalary(103000);
try {
FileOutputStream fos = new FileOutputStream(FILE_DIRECTORY);
ObjectOutputStream ous = new ObjectOutputStream(fos);
ous.writeObject(employee);
ous.close();
fos.close();
System.out.println("Serialized data is saved in " + FILE_DIRECTORY + ".");
} catch (IOException e) {
e.printStackTrace();
}
}
public void test() {
Employee emp1 = new EmployeeImpl();
emp1.setFirstName("Kevin");
emp1.setLastName("Moore");
emp1.setGender("Male");
emp1.setAge(30);
Address add = new AddressImpl();
add.setStreet("600 Chromakey Dr.");
add.setCity("Roswell");
add.setState("NM");
add.setCountry("USA");
add.setPostalCode("21872");
Cubicle cube1 = new CubicleImpl();
cube1.setLength(7.7f);
cube1.setWidth(12.2f);
cube1.setHeight(5.0f);
emp1.setAddress(add);
cube1.setEmployee(emp1);
((DatabaseSession) getSession()).insertObject(add);
getAbstractSession().insertObject(cube1);
// Employee is private owned so should be inserted along with Cubicle.
}
/**
* Create the employee but don't commit the change to the database, instead keep it in the
* extended persistence context.
*
* @param name
* @param address
* @param id
*/
@Override
@TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
public void createEmployee(String name, String address, int id) {
Employee emp = new Employee();
emp.setId(id);
emp.setAddress(address);
emp.setName(name);
em.persist(emp);
}
/** Create employee in provided EntityManager */
public void createEmployee(EntityManager em, String name, String address, int id) {
Employee emp = new Employee();
emp.setId(id);
emp.setAddress(address);
emp.setName(name);
try {
em.persist(emp);
em.flush();
} catch (Exception e) {
throw new RuntimeException("transactional failure while persisting employee entity", e);
}
}
public List<Employee> getEmployeeList(int size) {
List<Employee> empList = new ArrayList<Employee>();
Employee emp;
Random rnd = new Random();
for (int i = 0; i < size; i++) {
emp = new Employee();
emp.setEmpName("Employee " + i);
emp.setAddress("Address " + i);
emp.setDept("Dept " + i);
emp.setEmpAge(rnd.nextInt(50));
emp.setSallery(rnd.nextInt(100000));
empList.add(emp);
}
return empList;
}
public static void main(String... args) {
EntityManagerFactory entityManagerFactory =
Persistence.createEntityManagerFactory("bbm490-jpa");
EntityManager entityManager = entityManagerFactory.createEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
Address address1 = new Address("Guncicekleri Sok", null, "Cankaya", "Ankara", "TR", 33333);
entityManager.persist(address1);
Employee employee = new Employee("John", "Goodman", "dog", 1);
employee.setAddress(address1);
entityManager.persist(employee);
transaction.commit();
entityManager.close();
}
// 회원정보수정
@RequestMapping(value = "/information.modify", method = RequestMethod.POST)
public String Information_modify(HttpServletRequest request)
throws UnsupportedEncodingException, SQLException {
request.setCharacterEncoding("utf-8");
Employee employee = new Employee();
employee.setEmp_no(1);
employee.setDept_name("dept");
employee.setId("id");
employee.setEmp_name("amugae");
employee.setInhabit1(123456);
employee.setInhabit2(1234567);
employee.setPassword("1234");
employee.setAddress("Yongin");
employee.setJob_group("PM");
employee.setHigh_car("highschool");
employee.setCareer("3");
employee.setTechnique("no");
employee.setClass_posi("sawon");
request.getSession().setAttribute("employee", employee);
return "Information_modify";
}
@Override
public Employee selectEmployee(Integer id) throws SQLException {
// TODO Auto-generated method stub
String sql = "Select * from employees where (id = ? );";
DbConnection db = new DbConnection();
// Database db = new Database();
// db.setDefaultParameters();
// db.setConnection(true);
Connection con = null;
if (db == null) {
System.out.println("Null database");
System.exit(1);
}
con = db.getConnection();
if (con == null) {
System.out.println("Null connection");
System.exit(2);
}
PreparedStatement ps = null;
ps = con.prepareStatement(sql);
ps.setInt(1, id);
ResultSet r = ps.executeQuery();
Employee e = new Employee();
if (r != null) {
if (r.next()) {
e.setId(r.getInt("id"));
e.setFull_name(r.getString("full_name"));
e.setGender(r.getString("gender"));
e.setPhone(r.getString("phone"));
e.setAddress(r.getString("address"));
e.setUser_id(r.getInt("dept_id"));
}
r.close();
ps.close();
con.close();
}
return e;
// return null;
}
public void testDirtyButNotDirty() throws Exception {
EntityManager manager = getOrCreateEntityManager();
manager.getTransaction().begin();
Employee mark = new Employee();
mark.setName("Mark");
mark.setTitle("internal sales");
mark.setSex('M');
mark.setAddress("buckhead");
mark.setZip("30305");
mark.setCountry("USA");
Customer joe = new Customer();
joe.setName("Joe");
joe.setSex('M');
joe.setAddress("San Francisco");
joe.setZip("XXXXX");
joe.setCountry("USA");
joe.setComments("Very demanding");
joe.setSalesperson(mark);
Person yomomma = new Person();
yomomma.setName("mum");
yomomma.setSex('F');
manager.persist(mark);
manager.persist(joe);
manager.persist(yomomma);
long[] ids = {mark.getId(), joe.getId(), yomomma.getId()};
manager.getTransaction().commit();
manager.getTransaction().begin();
assertEquals(
manager
.createQuery("select p.address, p.name from Person p order by p.name")
.getResultList()
.size(),
3);
assertEquals(
manager
.createQuery("select p from Person p where p.class = Customer")
.getResultList()
.size(),
1);
manager.getTransaction().commit();
manager.getTransaction().begin();
List customers =
manager
.createQuery("select c from Customer c left join fetch c.salesperson")
.getResultList();
for (Iterator iter = customers.iterator(); iter.hasNext(); ) {
Customer c = (Customer) iter.next();
assertEquals(c.getSalesperson().getName(), "Mark");
}
assertEquals(customers.size(), 1);
manager.getTransaction().commit();
manager.getTransaction().begin();
customers = manager.createQuery("select c from Customer c").getResultList();
for (Iterator iter = customers.iterator(); iter.hasNext(); ) {
Customer c = (Customer) iter.next();
assertEquals(c.getSalesperson().getName(), "Mark");
}
assertEquals(customers.size(), 1);
manager.getTransaction().commit();
manager.getTransaction().begin();
mark = manager.find(Employee.class, new Long(ids[0]));
joe = (Customer) manager.find(Customer.class, new Long(ids[1]));
yomomma = manager.find(Person.class, new Long(ids[2]));
mark.setZip("30306");
assertEquals(
1,
manager.createQuery("select p from Person p where p.zip = '30306'").getResultList().size());
manager.remove(mark);
manager.remove(joe);
manager.remove(yomomma);
assertTrue(manager.createQuery("select p from Person p").getResultList().isEmpty());
manager.getTransaction().commit();
manager.close();
}
public static Company createCompany() {
// Create company
Company sampleCompany = new Company();
sampleCompany.setName("ACME Corporation");
// Create all employees
Employee craig = new Employee();
craig.setName("Craig");
craig.setAddress("Redmond");
craig.setSalary(123456);
Employee erik = new Employee();
erik.setName("Erik");
erik.setAddress("Utrecht");
erik.setSalary(12345);
Employee ralf = new Employee();
ralf.setName("Ralf");
ralf.setAddress("Koblenz");
ralf.setSalary(1234);
Employee ray = new Employee();
ray.setName("Ray");
ray.setAddress("Redmond");
ray.setSalary(234567);
Employee klaus = new Employee();
klaus.setName("Klaus");
klaus.setAddress("Boston");
klaus.setSalary(23456);
Employee karl = new Employee();
karl.setName("Karl");
karl.setAddress("Riga");
karl.setSalary(2345);
Employee joe = new Employee();
joe.setName("Joe");
joe.setAddress("Wifi City");
joe.setSalary(2344);
// Create research department
Department research = new Department();
research.setManager(craig);
research.setName("Research");
research.getEmployees().add(erik);
research.getEmployees().add(ralf);
sampleCompany.getDepts().add(research);
// Create development department
Department development = new Department();
development.setManager(ray);
development.setName("Development");
sampleCompany.getDepts().add(development);
// Create sub-department dev1
Department dev1 = new Department();
dev1.setName("Dev1");
dev1.setManager(klaus);
development.getSubdepts().add(dev1);
// Create sub-department dev11
Department dev11 = new Department();
dev11.setName("Dev1.1");
dev11.setManager(karl);
dev11.getEmployees().add(joe);
dev1.getSubdepts().add(dev11);
return sampleCompany;
}
