iSharkFly-Docs/java-tutorials
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

minor formatting cleanuop

Browse Source
This commit is contained in:
eugenp 2017-04-18 11:27:58 +03:00
parent 1aff8ca17d
commit 6c181db567
6 changed files with 215 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
mybatis/src/main/java/com/baeldung/mybatis/mapper/AddressMapper.java
View File

@ -4,21 +4,18 @@ import com.baeldung.mybatis.model.Address;
import com.baeldung.mybatis.model.Person; import com.baeldung.mybatis.model.Person;
import org.apache.ibatis.annotations.*; import org.apache.ibatis.annotations.*;
public interface AddressMapper { public interface AddressMapper {
@Insert("Insert into address (streetAddress,personId) values(#{streetAddress},#{personId})") @Insert("Insert into address (streetAddress,personId) values(#{streetAddress},#{personId})")
@Options(useGeneratedKeys = true,flushCache=true ) @Options(useGeneratedKeys = true, flushCache = true)
public Integer saveAddress(Address address); public Integer saveAddress(Address address);
@Select("SELECT addressId, streetAddress FROM Address WHERE addressId = #{addressId}") @Select("SELECT addressId, streetAddress FROM Address WHERE addressId = #{addressId}")
@Results(value = { @Results(value = { @Result(property = "addressId", column = "addressId"),
@Result(property = "addressId", column = "addressId"), @Result(property = "streetAddress", column = "streetAddress"),
@Result(property = "streetAddress", column = "streetAddress"), @Result(property = "person", column = "personId", javaType = Person.class, one = @One(select = "getPerson")) })
@Result(property = "person", column = "personId",javaType =Person.class,one=@One(select = "getPerson")) Address getAddresses(Integer addressID);
})
Address getAddresses(Integer addressID);
@Select("SELECT personId FROM address WHERE addressId = #{addressId})") @Select("SELECT personId FROM address WHERE addressId = #{addressId})")
Person getPerson(Integer personId); Person getPerson(Integer personId);
} }

51
mybatis/src/main/java/com/baeldung/mybatis/mapper/PersonMapper.java
View File

@ -9,44 +9,39 @@ import org.apache.ibatis.mapping.StatementType;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
public interface PersonMapper { public interface PersonMapper {
@Insert("Insert into person(name) values (#{name})") @Insert("Insert into person(name) values (#{name})")
public Integer save(Person person); public Integer save(Person person);
@Update("Update Person set name= #{name} where personId=#{personId}") @Update("Update Person set name= #{name} where personId=#{personId}")
public void updatePerson(Person person); public void updatePerson(Person person);
@Delete("Delete from Person where personId=#{personId}") @Delete("Delete from Person where personId=#{personId}")
public void deletePersonById(Integer personId); public void deletePersonById(Integer personId);
@Select("SELECT person.personId, person.name FROM person WHERE person.personId = #{personId}") @Select("SELECT person.personId, person.name FROM person WHERE person.personId = #{personId}")
Person getPerson(Integer personId); Person getPerson(Integer personId);
@Select("Select personId,name from Person where personId=#{personId}") @Select("Select personId,name from Person where personId=#{personId}")
@Results(value ={ @Results(value = { @Result(property = "personId", column = "personId"), @Result(property = "name", column = "name"),
@Result(property = "personId", column = "personId"), @Result(property = "addresses", javaType = List.class, column = "personId", many = @Many(select = "getAddresses"))
@Result(property="name", column = "name"),
@Result(property = "addresses",javaType = List.class,column = "personId",
many=@Many(select = "getAddresses"))
}) })
public Person getPersonById(Integer personId); public Person getPersonById(Integer personId);
@Select("select addressId,streetAddress,personId from address where personId=#{personId}") @Select("select addressId,streetAddress,personId from address where personId=#{personId}")
public Address getAddresses(Integer personId); public Address getAddresses(Integer personId);
@Select("select * from Person ") @Select("select * from Person ")
@MapKey("personId") @MapKey("personId")
Map<Integer,Person> getAllPerson(); Map<Integer, Person> getAllPerson();
@SelectProvider(type=MyBatisUtil.class,method="getPersonByName") @SelectProvider(type = MyBatisUtil.class, method = "getPersonByName")
public Person getPersonByName(String name); public Person getPersonByName(String name);
@Select(value = "{ CALL getPersonByProc( #{personId, mode=IN, jdbcType=INTEGER})}")
@Select(value= "{ CALL getPersonByProc( #{personId, mode=IN, jdbcType=INTEGER})}") @Options(statementType = StatementType.CALLABLE)
@Options(statementType = StatementType.CALLABLE) public Person getPersonByProc(Integer personId);
public Person getPersonByProc(Integer personId);
} }

63
mybatis/src/main/java/com/baeldung/mybatis/model/Address.java
View File

@ -1,49 +1,46 @@
package com.baeldung.mybatis.model; package com.baeldung.mybatis.model;
public class Address { public class Address {
private Integer addressId; private Integer addressId;
private String streetAddress; private String streetAddress;
private Integer personId; private Integer personId;
public Address() { public Address() {
} }
public Integer getPersonId() { public Integer getPersonId() {
return personId; return personId;
} }
public void setPersonId(Integer personId) { public void setPersonId(Integer personId) {
this.personId = personId; this.personId = personId;
} }
public Address(String streetAddress) {
this.streetAddress = streetAddress;
}
public Person getPerson() {
return person;
}
public Address(String streetAddress) { public void setPerson(Person person) {
this.streetAddress =streetAddress; this.person = person;
} }
public Person getPerson() { private Person person;
return person;
}
public void setPerson(Person person) { public Address(int i, String name) {
this.person = person; this.streetAddress = name;
} }
private Person person; public Integer getAddressId() {
return addressId;
}
public Address(int i, String name) { public String getStreetAddress() {
this.streetAddress = name; return streetAddress;
} }
public Integer getAddressId() {
return addressId;
}
public String getStreetAddress() {
return streetAddress;
}
} }

52
mybatis/src/main/java/com/baeldung/mybatis/model/Person.java
View File

@ -3,38 +3,38 @@ package com.baeldung.mybatis.model;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class Person { public class Person {
private Integer personId; private Integer personId;
private String name; private String name;
private List<Address> addresses; private List<Address> addresses;
public Person() { public Person() {
} }
public Person(Integer personId, String name) { public Person(Integer personId, String name) {
this.personId=personId; this.personId = personId;
this.name = name; this.name = name;
addresses = new ArrayList<Address>(); addresses = new ArrayList<Address>();
} }
public Person(String name) { public Person(String name) {
this.name=name; this.name = name;
} }
public Integer getPersonId() { public Integer getPersonId() {
return personId; return personId;
} }
public String getName() { public String getName() {
return name; return name;
} }
public void addAddress(Address address){
addresses.add(address);
}
public List<Address> getAddresses() { public void addAddress(Address address) {
return addresses; addresses.add(address);
} }
public List<Address> getAddresses() {
return addresses;
}
} }

52
mybatis/src/main/java/com/baeldung/mybatis/utils/MyBatisUtil.java
View File

@ -16,33 +16,35 @@ import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
public class MyBatisUtil { public class MyBatisUtil {
public static final String DRIVER = "org.apache.derby.jdbc.EmbeddedDriver"; public static final String DRIVER = "org.apache.derby.jdbc.EmbeddedDriver";
public static final String URL = "jdbc:derby:testdb1;create=true"; public static final String URL = "jdbc:derby:testdb1;create=true";
public static final String USERNAME = "sa"; public static final String USERNAME = "sa";
public static final String PASSWORD = "pass123"; public static final String PASSWORD = "pass123";
private static SqlSessionFactory sqlSessionFactory; private static SqlSessionFactory sqlSessionFactory;
public static SqlSessionFactory buildqlSessionFactory(){ public static SqlSessionFactory buildqlSessionFactory() {
DataSource dataSource=new PooledDataSource(DRIVER, URL, USERNAME, PASSWORD); DataSource dataSource = new PooledDataSource(DRIVER, URL, USERNAME, PASSWORD);
Environment environment=new Environment("Development",new JdbcTransactionFactory(),dataSource); Environment environment = new Environment("Development", new JdbcTransactionFactory(), dataSource);
Configuration configuration = new Configuration(environment); Configuration configuration = new Configuration(environment);
configuration.addMapper(PersonMapper.class); configuration.addMapper(PersonMapper.class);
configuration.addMapper(AddressMapper.class); configuration.addMapper(AddressMapper.class);
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(configuration); SqlSessionFactory factory = builder.build(configuration);
return factory; return factory;
} }
public static SqlSessionFactory getSqlSessionFactory(){ public static SqlSessionFactory getSqlSessionFactory() {
return sqlSessionFactory; return sqlSessionFactory;
} }
public String getPersonByName(String name){ public String getPersonByName(String name) {
return new SQL(){{ return new SQL() {
SELECT("*"); {
FROM("person"); SELECT("*");
WHERE("name like #{name} || '%'"); FROM("person");
}}.toString(); WHERE("name like #{name} || '%'");
} }
}.toString();
}
} }

202
mybatis/src/test/java/com/baeldung/mybatis/mapper/PersonMapperTest.java
View File

@ -18,132 +18,128 @@ import static junit.framework.TestCase.assertEquals;
public class PersonMapperTest { public class PersonMapperTest {
SqlSession session; SqlSession session;
@Before @Before
public void setup() throws SQLException { public void setup() throws SQLException {
session = MyBatisUtil.buildqlSessionFactory().openSession(); session = MyBatisUtil.buildqlSessionFactory().openSession();
createTables(session); createTables(session);
} }
private void createTables(SqlSession session) throws SQLException { private void createTables(SqlSession session) throws SQLException {
String createPersonTable = "create table person (" String createPersonTable = "create table person (" + "personId integer not null generated always as"
+ "personId integer not null generated always as" + " identity (start with 1, increment by 1), " + "name varchar(30) not null, "
+ " identity (start with 1, increment by 1), " + "constraint primary_key_person primary key (personId))";
+ "name varchar(30) not null, "
+ "constraint primary_key_person primary key (personId))";
String createAddressTable = "create table address (" String createAddressTable = "create table address (" + "addressId integer not null generated always as"
+ "addressId integer not null generated always as" + " identity (start with 1, increment by 1), " + "streetAddress varchar(300), personId integer, "
+ " identity (start with 1, increment by 1), " + "constraint primary_key_address primary key (addressId))";
+ "streetAddress varchar(300), personId integer, "
+ "constraint primary_key_address primary key (addressId))";
String alterTable="ALTER TABLE " + String alterTable = "ALTER TABLE "
" address ADD CONSTRAINT fk_person FOREIGN KEY (personId) REFERENCES person (personId)"; + " address ADD CONSTRAINT fk_person FOREIGN KEY (personId) REFERENCES person (personId)";
session.getConnection().createStatement().execute(createPersonTable);
session.getConnection().createStatement().execute(createAddressTable);
session.getConnection().createStatement().execute(alterTable);
session.getConnection().createStatement().execute(createPersonTable); }
session.getConnection().createStatement().execute(createAddressTable);
session.getConnection().createStatement().execute(alterTable);
} @Test
public void whenPersonAdressSaved_ThenPersonAddressCanBeQueried() {
Person person = new Person("Baljeet S");
Address address = new Address("Pune");
PersonMapper personMapper = session.getMapper(PersonMapper.class);
Integer id = personMapper.save(person);
address.setPersonId(id);
AddressMapper addressMapper = session.getMapper(AddressMapper.class);
addressMapper.saveAddress(address);
@Test Person returnedPerson = personMapper.getPersonById(id);
public void whenPersonAdressSaved_ThenPersonAddressCanBeQueried(){ assertEquals("Baljeet S", returnedPerson.getName());
Person person=new Person("Baljeet S"); assertEquals("Pune", returnedPerson.getAddresses().get(0).getStreetAddress());
Address address = new Address("Pune"); }
PersonMapper personMapper=session.getMapper(PersonMapper.class);
Integer id =personMapper.save(person);
address.setPersonId(id);
AddressMapper addressMapper=session.getMapper(AddressMapper.class);
addressMapper.saveAddress(address);
Person returnedPerson= personMapper.getPersonById(id); @Test
assertEquals("Baljeet S", returnedPerson.getName()); public void whenPersonSaved_ThenPersonCanBeQueried() {
assertEquals("Pune", returnedPerson.getAddresses().get(0).getStreetAddress()); Person person = new Person("Baljeet S");
} Address address = new Address("Pune");
PersonMapper personMapper = session.getMapper(PersonMapper.class);
Integer id = personMapper.save(person);
address.setPersonId(id);
AddressMapper addressMapper = session.getMapper(AddressMapper.class);
addressMapper.saveAddress(address);
@Test Person returnedPerson = personMapper.getPerson(id);
public void whenPersonSaved_ThenPersonCanBeQueried(){ assertEquals("Baljeet S", returnedPerson.getName());
Person person=new Person("Baljeet S"); }
Address address = new Address("Pune");
PersonMapper personMapper=session.getMapper(PersonMapper.class);
Integer id =personMapper.save(person);
address.setPersonId(id);
AddressMapper addressMapper=session.getMapper(AddressMapper.class);
addressMapper.saveAddress(address);
Person returnedPerson= personMapper.getPerson(id); @Test
assertEquals("Baljeet S", returnedPerson.getName()); public void whenPersonUpdated_ThenPersonIsChanged() {
} Person person = new Person("Baljeet S");
Address address = new Address("Pune");
PersonMapper personMapper = session.getMapper(PersonMapper.class);
Integer id = personMapper.save(person);
address.setPersonId(id);
AddressMapper addressMapper = session.getMapper(AddressMapper.class);
addressMapper.saveAddress(address);
@Test personMapper.updatePerson(new Person(id, "Baljeet1"));
public void whenPersonUpdated_ThenPersonIsChanged(){ Person returnedPerson = personMapper.getPerson(id);
Person person=new Person("Baljeet S"); assertEquals("Baljeet1", returnedPerson.getName());
Address address = new Address("Pune"); }
PersonMapper personMapper=session.getMapper(PersonMapper.class);
Integer id =personMapper.save(person);
address.setPersonId(id);
AddressMapper addressMapper=session.getMapper(AddressMapper.class);
addressMapper.saveAddress(address);
personMapper.updatePerson(new Person(id,"Baljeet1")); @Test
Person returnedPerson= personMapper.getPerson(id); public void whenPersoSaved_ThenMapIsReturned() {
assertEquals("Baljeet1", returnedPerson.getName()); Person person = new Person("Baljeet S");
} Address address = new Address("Pune");
@Test PersonMapper personMapper = session.getMapper(PersonMapper.class);
public void whenPersoSaved_ThenMapIsReturned(){ Integer id = personMapper.save(person);
Person person=new Person("Baljeet S"); address.setPersonId(id);
Address address = new Address("Pune"); AddressMapper addressMapper = session.getMapper(AddressMapper.class);
PersonMapper personMapper=session.getMapper(PersonMapper.class); addressMapper.saveAddress(address);
Integer id =personMapper.save(person);
address.setPersonId(id);
AddressMapper addressMapper=session.getMapper(AddressMapper.class);
addressMapper.saveAddress(address);
Map<Integer, Person> returnedPerson= personMapper.getAllPerson(); Map<Integer, Person> returnedPerson = personMapper.getAllPerson();
assertEquals(1, returnedPerson.size()); assertEquals(1, returnedPerson.size());
} }
@Test @Test
public void whenPersonSearched_ThenResultIsReturned(){ public void whenPersonSearched_ThenResultIsReturned() {
Person person=new Person("Baljeet S"); Person person = new Person("Baljeet S");
Address address = new Address("Pune"); Address address = new Address("Pune");
PersonMapper personMapper=session.getMapper(PersonMapper.class); PersonMapper personMapper = session.getMapper(PersonMapper.class);
Integer id =personMapper.save(person); Integer id = personMapper.save(person);
address.setPersonId(id); address.setPersonId(id);
AddressMapper addressMapper=session.getMapper(AddressMapper.class); AddressMapper addressMapper = session.getMapper(AddressMapper.class);
addressMapper.saveAddress(address); addressMapper.saveAddress(address);
Person returnedPerson= personMapper.getPersonByName("Baljeet S"); Person returnedPerson = personMapper.getPersonByName("Baljeet S");
assertEquals("Baljeet S", returnedPerson.getName()); assertEquals("Baljeet S", returnedPerson.getName());
} }
@Test @Test
public void whenAddressSearched_ThenResultIsReturned(){ public void whenAddressSearched_ThenResultIsReturned() {
Person person=new Person("Baljeet S"); Person person = new Person("Baljeet S");
Address address = new Address("Pune"); Address address = new Address("Pune");
PersonMapper personMapper=session.getMapper(PersonMapper.class); PersonMapper personMapper = session.getMapper(PersonMapper.class);
Integer id =personMapper.save(person); Integer id = personMapper.save(person);
address.setPersonId(id); address.setPersonId(id);
AddressMapper addressMapper=session.getMapper(AddressMapper.class); AddressMapper addressMapper = session.getMapper(AddressMapper.class);
Integer addressId=addressMapper.saveAddress(address); Integer addressId = addressMapper.saveAddress(address);
Address returnedAddress=addressMapper.getAddresses(addressId); Address returnedAddress = addressMapper.getAddresses(addressId);
assertEquals("Pune", returnedAddress.getStreetAddress()); assertEquals("Pune", returnedAddress.getStreetAddress());
} }
@After @After
public void cleanup() throws SQLException { public void cleanup() throws SQLException {
session.getConnection().createStatement().execute("drop table address"); session.getConnection().createStatement().execute("drop table address");
session.getConnection().createStatement().execute("drop table person"); session.getConnection().createStatement().execute("drop table person");
session.close(); session.close();
} }
} }