@Configuration @EnableAutoConfiguration public class Application { public static void main(String[] args) { ConfigurableApplicationContext context = SpringApplication.run(Application.class); PersonRepository repository = context.getBean(PersonRepository.class); for (Person person : repository.findAll()) { System.out.println(person); } context.close(); } }Although this looks similar to the Hibernate JPA previously, there are some significant changes. The first is the use of a Repository interface, PersonRepository. This has to descend from the Spring Data Repository interface, usually via another interface:
public interface PersonRepository extends CrudRepository<Person, Long> { }I’ve used CrudRepository, the most basic, and given it the class name of the POJO and the type of the unique identifier, which is a Long. Notice that you have to use the class equivalent of the primitive type. You don’t need to define anything else if you don’t want to; CrudRepository defines the basic functions as standard:
public interface CrudRepository<T extends Object, ID extends Serializable> extends Repository<T, ID> { public <S extends T> S save(S s); public <S extends T> Iterable<S> save(Iterable<S> itrbl); public T findOne(ID id); public boolean exists(ID id); public Iterable<T> findAll(); public Iterable<T> findAll(Iterable<ID> itrbl); public long count(); public void delete(ID id); public void delete(T t); public void delete(Iterable<? extends T> itrbl); public void deleteAll(); }As before, the field mappings have to be put directly in the POJO using annotations. Something to remember is that with Spring JPA you have to make sure the column names are lower case.
spring.datasource.url=jdbc:jtds:sqlserver://localhost:1433/A_DB spring.datasource.username=aaron spring.datasource.password=******** spring.datasource.driverClassName=net.sourceforge.jtds.jdbc.DriverYou may have noticed in the application definition is the use of the EnableAutoConfiguration annotation. This is from Spring Boot, which is our next subject.
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.1.8.RELEASE</version> </parent>… which goes in the project root. Next you want something to tell Spring Boot to pull in the Data JPA layer:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>… which goes in the dependencies. Clear everything else out of the dependencies: this will cause all kinds of errors in the code, but resist the temptation to fix this by pulling in the dependencies. You will regret it if you don’t. Do a build (or clean and build), you’ll find that new dependencies have been pulled in via the parent and you don’t have to define anything. This also sorts out any import errors.
<dependency> <groupId>net.sourceforge.jtds</groupId> <artifactId>jtds</artifactId> <version>1.2</version> </dependency>You will be surprised to find that all this works straight away with no other configuration.
public static void main(String[] args) {
SpringApplication.run(Application.class);
}
Exactly as before, just without the data code. This has been moved to the web service class, MyController:@RestController public class PersonController { @Autowired private PersonRepository repository; @RequestMapping("/") public String index() { StringBuilder sb = new StringBuilder(); sb.append("<!DOCTYPE html>").append("<html lang='en'>"); sb.append("<head>").append("<meta charset='UTF-8'>"); sb.append("<title>Something, something</title>").append("</head>"); sb.append("<body>"); sb.append("<table>"); for (Person person : repository.findAll()) { sb.append("<tr>"); sb.append("<td>").append(person.getId()).append("</td>"); sb.append("<td>").append(person.getFirstName()).append("</td>"); sb.append("<td>").append(person.getLastName()).append("</td>"); sb.append("</tr>"); } sb.append("</table>"); sb.append("</body>"); sb.append("</html>"); return sb.toString(); } }The class is designated a RestController, which tells Spring that it’s the class that handles http requests as REST requests. The RequestMapping annotation tells it which path to respond to, in this case the root. I’m responding with a string at this point and creating a simple web page as the payload.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
The former seems to be mostly used to enable the web services, but also to prevent Tomcat being used. Instead it used Jetty, which is simpler. The only other thing needed is to tell Maven that this is a Boot application, rather than a Java one:<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
That’s pretty much it. If you now run up the application, it will start Jetty on port 8080 and the response will be a web page with the Persons loaded from the database.@RequestMapping("/") public Person[] index() { ListfindAll returns an Iterable, so this needs to be converted to an array via ArrayList. The array of JobType objects is coded to JSON and sent as the response automatically.personList = new ArrayList (); personList.addAll((Collection) repository.findAll()); return personList.toArray(new Person[0]); }
try { Connection connection = null; ResultSet resultset = null; try { Class.forName("net.sourceforge.jtds.jdbc.Driver").newInstance(); connection = DriverManager.getConnection("jdbc:jtds:sqlserver://localhost:1433/A_DB", "aaron", "********"); Statement statement = connection.createStatement(); resultset = statement.executeQuery("SELECT " + "firstName, " + "lastName, " + "gender " + "FROM person"); Person person; while (resultset.next()) { person = new Person(); person.setFirstName(resultset.getString("firstName")); person.setLastName(resultset.getString("lastName")); person.setGender(resultset.getString("gender")); System.out.println(person); } } finally { if (resultset != null) { resultset.close(); } if (connection != null) { connection.close(); } } } catch (ClassNotFoundException ex) { Logger.getLogger(ConnectingUsingJDBC.class.getName()).log(Level.SEVERE, null, ex); } catch (InstantiationException ex) { Logger.getLogger(ConnectingUsingJDBC.class.getName()).log(Level.SEVERE, null, ex); } catch (IllegalAccessException ex) { Logger.getLogger(ConnectingUsingJDBC.class.getName()).log(Level.SEVERE, null, ex); } catch (SQLException ex) { Logger.getLogger(ConnectingUsingJDBC.class.getName()).log(Level.SEVERE, null, ex); }
try { Connection connection = null; ResultSet resultset = null Class.forName("net.sourceforge.jtds.jdbc.Driver").newInstance(); try(connection = DriverManager.getConnection("jdbc:jtds:sqlserver://localhost:1433/A_DB", "aaron", "********"); Statement statement = connection.createStatement(); resultset = statement.executeQuery("SELECT " + "firstName, " + "lastName, " + "gender " + "FROM person")){ Person person; while (resultset.next()) { person = new Person(); person.setFirstName(resultset.getString("firstName")); person.setLastName(resultset.getString("lastName")); person.setGender(resultset.getString("gender")); System.out.println(person); } } finally { if (resultset != null) { resultset.close(); } if (connection != null) { connection.close(); } } } catch (InstantiationException | IllegalAccessException | SQLException | ClassNotFoundException ex) { Logger.getLogger(ConnectingUsingJDBC.class.getName()).log(Level.SEVERE, null, ex); }
“Object-relational mapping (ORM) is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language.”
Configuration config = new Configuration(); config.configure(); Session session = config.buildSessionFactory().openSession(); Transaction tx = session.beginTransaction(); try { List result = session.createQuery("from person").list(); for (Person person : (List<Person>) result) { System.out.println(person); } } finally { tx.commit(); session.close(); }
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">net.sourceforge.jtds.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:jtds:sqlserver://localhost:1433/A_DB</property> <property name="hibernate.connection.username">aaron</property> <property name="hibernate.connection.password">********</property> <mapping resource="jobtype.hbm.xml"/> </session-factory> </hibernate-configuration>
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="org.laughing.lemon.Person" table="person"> <id column="ID" name="ID" type="int"> <generator class="assigned"/> </id> <property column="firstName" name="firstName" type="string"/> <property column="lastName" name="lastName" type="string"/> <property column="gender" name="gender" type="string"/> </class> </hibernate-mapping>
import java.io.Serializable; public class Person implements Serializable { private int ID; private String firstName; private String lastName; private String gender;
EntityManagerFactory entityManagerFactory =
Persistence.createEntityManagerFactory("org.laughing.lemon");
EntityManager entityManager = entityManagerFactory.createEntityManager();
List<person> result =
entityManager.createQuery("from org.laughing.lemon.Person", Person.class).getResultList();
for (Person person : result) {
System.out.println(person);
}
entityManager.close();
<?xml version="1.0" encoding="UTF-8"?> <persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"> <persistence-unit name="org.laughing.lemon" transaction-type="RESOURCE_LOCAL"> <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider> <class>org.laughing.lemon.Person</class> <properties> <property name="javax.persistence.jdbc.url" value="jdbc:jtds:sqlserver://localhost:1433/A_DB"/> <property name="javax.persistence.jdbc.password" value="********"/> <property name="javax.persistence.jdbc.driver" value="net.sourceforge.jtds.jdbc.Driver"/> <property name="javax.persistence.jdbc.user" value="aaron"/> </properties> </persistence-unit> </persistence>
import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.Table; @Entity @Table(name="person") public class Person implements Serializable { @Id @Column(name="id") private int ID; @Column(name="firstname") private String firstName; @Column(name="lastname") private String lastName; @Column(name="gender") private String gender;
public class DemoSuperClass { protected ListcreateNameList() { List returnList = new ArrayList (); returnList.add("Steve Stranger"); returnList.add("James Jones"); returnList.add("Harry Harnot"); returnList.add("Bill Blogger"); return returnList; } public void printNameList() { List nameList = createNameList(); for(String name: nameList) System.out.printLn(name.split(" ")[0]); //prints the first name } }
private class DemoSubClass { //class in the test harness @Override protected ListcreateNameList() { List returnList = new ArrayList (); return returnList; } }
public class DemoConstructorClass { protected DemoConstructorClass() { procedure1(); } protected void procedure1() { System.out.println("procedure1"); } } //in the test harness private class TestDemoConstructor extends DemoConstructorClass { @Override protected void procedure1() { System.out.println("Overriden procedure1"); } }
public class SingletonClass { private static SingletonClass instance = new SingletonClass(); public static SingletonClass getInstance() { return instance; } protected SingletonClass() { procedure1(); } protected void procedure1() { System.out.println("procedure1 called"); } } //in use, say, in the test harness SingletonClass instance = SingletonClass.getInstance();Notice that the constructor is protected and cannot be accessed from outside the class. The only way to create the class is through getInstance and that returns the private static instance field created when the class is first referenced. Sub-classing and overriding has no effect, because the call to constructor happens as soon as the class gets referenced and the private static instance gets created. Mockito spies don't work either for the same reason. Enter PowerMock.
public static void replacement() { System.out.println("replacement"); } public void testGetInstance() { //procedure1 has to be static to be replaced MemberModifier.replace(MemberModifier.method(SingletonClass.class, "procedure1")) .with(MemberModifier.method(this.getClass(), "replacement")); SingletonClass result = SingletonClass.getInstance(); }
@Test public void testOneWhere() { //select with one criteria SQLBuilder instance = new SQLBuilder(); instance.select().table("A_TABLE"); String result = instance.where("A_COLUMN", "A_VALUE").build(); assertTrue("result is not proper SQL: " + result, result.equals("SELECT * FROM A_TABLE WHERE A_COLUMN = \"A_VALUE\"")); }
Scenario: with a where clause Given a new SQLBuilder object When select is called And table is set to A_TABLE And where is set to A_COLUMN equals A_VALUE And build is called Then the result is SELECT * FROM TABLE WHERE A_COLUMN = "A_VALUE"
@When("select is called") public void selectIsCalled() { sqlBuilder.select(); } @When("table is set to $table") public void tableSetToTable(String table){ sqlBuilder.table(table); } //etc.
MATCH (n:Person)-[:KNOWS]->(m:Person) WHERE n.name="Alice"
//a really dumb message sending class public class MessageSender { public void sendMessage(String message) { System.out.println(message); } } //another dumb class that uses the message sender public class MessageUser { //a reference to the sender object private MessageSender messageSender; //the message sender object is created in the constructor public MessageUser() { this.messageSender = new MessageSender(); } //send the message via the sender public void sendMessage(String message) { messageSender.sendMessage(message); } } //the main class that uses the message classes public class MessageMain { public static void main(String[] args) { MessageUser messageUser = new MessageUser(); messageUser.sendMessage("This is a test"); } }
public interface MessageSender { public void sendMessage(String message); } //an implementation of the interface public class SystemMessageSender implements MessageSender { public void sendMessage(String message) { System.out.println(message); } }
public class MessageUser { //a reference to the interface private MessageSender messageSender; //the interface is sent to the object using the constructor public MessageUser(MessageSender messageSender) { this.messageSender = messageSender; } public void sendMessage(String message) { messageSender.sendMessage(message); } }
public class MessageMain { public static void main(String[] args) { SystemMessageSender messageSender = new SystemMessageSender(); MessageUser messageUser = new MessageUser(messageSender); messageUser.sendMessage("This is a test"); } }
//an implementation of the interface public class EMailMessageSender implements MessageSender { public void sendMessage(String message) { EMail.textMessage(message); } }
EMailMessageSender messageSender = new EMailMessageSender(); MessageUser messageUser = new MessageUser(messageSender); messageUser.sendMessage("This is a test");
public class MessageModule extends AbstractModule { protected void configure() { bind(MessageSender.class).to(SystemMessageSender.class); } }
Injector injector = Guice.createInjector(new MessageModule()); MessageUser messageUser = injector.getInstance(MessageUser.class); messageUser.sendMessage("This is a test");
@Inject public MessageUser(MessageSender messageSender) { this.messageSender = messageSender; }
