domingo, 8 de octubre de 2017

Spring Data JPA using Hibernate and Java Configuration with Annotations

  22:50:00   No comments   Edit
In this tutorial I’ll show you how to use Spring Data JPA to integrate a relational database (PostgreSQL in my example) into a Spring Boot application.
I’ll use these technologies and tools:
  • Spring Tool Suite (STS) 3.8.4.RELEASE
  • Java 8
  • Spring Boot 1.5.3.RELEASE
  • Maven 3.3.9
  • PostgreSQL 9.6.2

1. The Project Structure

The final folder structure of our project.
The folder structure of the Spring Data JPA project as seen in STS

2. Create a new Spring Boot project

If you’re using STS, you can easily create a starter project by either selecting File > New > Spring Starter Project from the main menu or right-clicking on the Package Explorer and select New > Spring Starter Project.
STS command to create a new Spring Starter Project
Dialog window to set parameters for the Spring Data JPA project
The list of dependencies of the Spring Data JPA project
In case you’re using another IDE like Eclipse, Netbeans or IntelliJ IDEA, you can create a new Maven project and add to the pom.xml file the dependencies listed in the next paragraph.

3. Maven Dependencies

spring-boot-starter-data-jpa is the fundamental dependency for our project, then we need the driver for whatever SQL database we have chosen, in this case postgresql.
  • pom.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. <modelVersion>4.0.0</modelVersion>
  6. <groupId>com.thomasvitale</groupId>
  7. <artifactId>Application</artifactId>
  8. <version>0.0.1-SNAPSHOT</version>
  9. <packaging>jar</packaging>
  11. <name>Application</name>
  12. <description>Demo application for Spring Data JPA</description>
  14. <parent>
  15. <groupId>org.springframework.boot</groupId>
  16. <artifactId>spring-boot-starter-parent</artifactId>
  17. <version>1.5.3.RELEASE</version>
  18. <relativePath/> <!-- lookup parent from repository -->
  19. </parent>
  21. <properties>
  22. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24. <java.version>1.8</java.version>
  25. </properties>
  27. <dependencies>
  29. <dependency>
  30. <groupId>org.springframework.boot</groupId>
  31. <artifactId>spring-boot-starter-data-jpa</artifactId>
  32. </dependency>
  34. <dependency>
  35. <groupId>org.postgresql</groupId>
  36. <artifactId>postgresql</artifactId>
  37. <scope>runtime</scope>
  38. </dependency>
  40. <dependency>
  41. <groupId>org.springframework.boot</groupId>
  42. <artifactId>spring-boot-starter-test</artifactId>
  43. <scope>test</scope>
  44. </dependency>
  46. </dependencies>
  48. <build>
  49. <plugins>
  50. <plugin>
  51. <groupId>org.springframework.boot</groupId>
  52. <artifactId>spring-boot-maven-plugin</artifactId>
  53. </plugin>
  54. </plugins>
  55. </build>
  57. </project>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.thomasvitale</groupId>
  <artifactId>Application</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>Application</name>
  <description>Demo application for Spring Data JPA</description>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
  
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <scope>runtime</scope>
    </dependency>
  
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>
I’m using PostgreSQL, but this example works fine also with other relational databases. For example, if you want to use MySQL, all you need to do is replace the postgresql dependency with the mysql one.
  1. <dependency>
  2. <groupId>mysql</groupId>
  3. <artifactId>mysql-connector-java</artifactId>
  4. <scope>runtime</scope>
  5. </dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>

4. Spring Configuration using Java Annotations and Hibernate

Spring lets you use either Java configuration or XML configuration or a mix of the two. I’ll use a pure Java configuration. There are a few implementations of JPA, in this example Hibernate is used. Its properties are stored in a dedicated file.
  • JpaConfig.java
  1. package com.thomasvitale;
  3. import java.util.Properties;
  5. import javax.persistence.EntityManagerFactory;
  6. import javax.sql.DataSource;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.context.annotation.PropertySource;
  12. import org.springframework.core.env.Environment;
  13. import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
  14. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
  15. import org.springframework.jdbc.datasource.DriverManagerDataSource;
  16. import org.springframework.orm.jpa.JpaTransactionManager;
  17. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
  18. import org.springframework.orm.jpa.vendor.Database;
  19. import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
  20. import org.springframework.transaction.PlatformTransactionManager;
  21. import org.springframework.transaction.annotation.EnableTransactionManagement;
  23. @Configuration
  24. @EnableTransactionManagement
  25. @EnableJpaRepositories(basePackages = "com.thomasvitale.repository")
  26. @PropertySource("classpath:jpa.properties")
  27. public class JpaConfig {
  29. @Autowired
  30. private Environment env;
  32. @Bean
  33. public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
  35. HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
  36. vendorAdapter.setDatabase(Database.POSTGRESQL);
  37. vendorAdapter.setGenerateDdl(true);
  39. LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
  40. em.setDataSource(dataSource());
  41. em.setPackagesToScan("com.thomasvitale.model");
  42. em.setJpaVendorAdapter(vendorAdapter);
  43. em.setJpaProperties(additionalProperties());
  45. return em;
  46. }
  48. @Bean
  49. public DataSource dataSource(){
  50. DriverManagerDataSource dataSource = new DriverManagerDataSource();
  51. dataSource.setDriverClassName(env.getProperty("hibernate.connection.driver_class"));
  52. dataSource.setUrl(env.getProperty("hibernate.connection.url"));
  53. dataSource.setUsername(env.getProperty("hibernate.connection.username"));
  54. dataSource.setPassword(env.getProperty("hibernate.connection.password"));
  55. return dataSource;
  56. }
  58. @Bean
  59. public PlatformTransactionManager transactionManager(EntityManagerFactory emf){
  60. JpaTransactionManager transactionManager = new JpaTransactionManager();
  61. transactionManager.setEntityManagerFactory(emf);
  63. return transactionManager;
  64. }
  66. @Bean
  67. public PersistenceExceptionTranslationPostProcessor exceptionTranslation(){
  68. return new PersistenceExceptionTranslationPostProcessor();
  69. }
  71. Properties additionalProperties() {
  72. Properties properties = new Properties();
  73. properties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
  74. properties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
  75. properties.setProperty("hibernate.current_session_context_class", env.getProperty("hibernate.current_session_context_class"));
  76. return properties;
  77. }
  79. }
package com.thomasvitale;

import java.util.Properties;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement 
@EnableJpaRepositories(basePackages = "com.thomasvitale.repository")
@PropertySource("classpath:jpa.properties")
public class JpaConfig {
  
  @Autowired
  private Environment env;

  @Bean
  public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
    
    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    vendorAdapter.setDatabase(Database.POSTGRESQL);
    vendorAdapter.setGenerateDdl(true);
    
    LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
    em.setDataSource(dataSource());
    em.setPackagesToScan("com.thomasvitale.model");
    em.setJpaVendorAdapter(vendorAdapter);
    em.setJpaProperties(additionalProperties());
 
    return em;
  }
  
  @Bean
  public DataSource dataSource(){
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName(env.getProperty("hibernate.connection.driver_class"));
    dataSource.setUrl(env.getProperty("hibernate.connection.url"));
    dataSource.setUsername(env.getProperty("hibernate.connection.username"));
    dataSource.setPassword(env.getProperty("hibernate.connection.password"));
    return dataSource;
  }
  
  @Bean
  public PlatformTransactionManager transactionManager(EntityManagerFactory emf){
    JpaTransactionManager transactionManager = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(emf);
  
    return transactionManager;
  }
  
  @Bean
  public PersistenceExceptionTranslationPostProcessor exceptionTranslation(){
    return new PersistenceExceptionTranslationPostProcessor();
  }

  Properties additionalProperties() {
    Properties properties = new Properties();
    properties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
    properties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
    properties.setProperty("hibernate.current_session_context_class", env.getProperty("hibernate.current_session_context_class"));
    return properties;
  }

}
  • jpa.properties
  1. hibernate.connection.username=db-user
  2. hibernate.connection.password=db-password
  3. hibernate.connection.url=jdbc:postgresql://localhost:5432/app
  4. hibernate.connection.driver_class=org.postgresql.Driver
  5. hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
  6. hibernate.current_session_context_class=thread
  7. hibernate.hbm2ddl.auto=validate
  8. hibernate.show_sql=false
  9. hibernate.format_sql=false
hibernate.connection.username=db-user
hibernate.connection.password=db-password
hibernate.connection.url=jdbc:postgresql://localhost:5432/app
hibernate.connection.driver_class=org.postgresql.Driver
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
hibernate.current_session_context_class=thread
hibernate.hbm2ddl.auto=validate
hibernate.show_sql=false
hibernate.format_sql=false
If you’re using MySQL, pay attention to replace line 36 of JpaConfig.java with this one: vendorAdapter.setDatabase(Database.MYSQL); and change the relative values in the jpa.properties file:
  1. hibernate.connection.url=jdbc:mysql://localhost:3306/app
  2. hibernate.connection.driver_class=com.mysql.jdbc.Driver
  3. hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.connection.url=jdbc:mysql://localhost:3306/app
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.dialect=org.hibernate.dialect.MySQLDialect

5. Person Model

For the Person entity, first of all I create a new table (persons) in my PostgreSQL database (called app).
  1. CREATE TABLE persons(
  2. id SERIAL,
  3. firstName VARCHAR(32),
  4. lastName VARCHAR(32),
  5. PRIMARY KEY(id)
  6. );
CREATE TABLE persons(
  id SERIAL,
  firstName VARCHAR(32),
  lastName VARCHAR(32),
  PRIMARY KEY(id)
);
Then I code the mapping object model. The @Table(name = "persons") annotation specifies in which table to save a Person object. The @GeneratedValue(strategy = GenerationType.IDENTITY) is quite general. In PostgreSQL I have defined the id attribute as SERIAL. In MySQL you probably want to use AUTO_INCREMENT. That’s just fine, it works with both of them.
  • Person.java
  1. package com.thomasvitale.model;
  3. import javax.persistence.Entity;
  4. import javax.persistence.GeneratedValue;
  5. import javax.persistence.GenerationType;
  6. import javax.persistence.Id;
  7. import javax.persistence.Table;
  9. @Entity
  10. @Table(name = "persons")
  11. public class Person {
  13. @Id
  14. @GeneratedValue(strategy = GenerationType.IDENTITY)
  15. private Integer id;
  17. private String firstName;
  18. private String lastName;
  20. public Person() {
  21. }
  23. public Person(String firstName, String lastName) {
  24. this.firstName = firstName;
  25. this.lastName = lastName;
  26. }
  28. public Integer getId() {
  29. return id;
  30. }
  32. public void setId(Integer id) {
  33. this.id = id;
  34. }
  36. public String getFirstName() {
  37. return firstName;
  38. }
  40. public void setFirstName(String firstName) {
  41. this.firstName = firstName;
  42. }
  44. public String getLastName() {
  45. return lastName;
  46. }
  48. public void setLastName(String lastName) {
  49. this.lastName = lastName;
  50. }
  52. @Override
  53. public String toString() {
  54. return firstName + " " + lastName;
  55. }
  56. }
package com.thomasvitale.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "persons")
public class Person {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Integer id;
  
  private String firstName;
  private String lastName;

  public Person() {
  }

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  public Integer getId() {
    return id;
  }

  public void setId(Integer id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return firstName + " " + lastName;
  }
}

6. Person Repository

Our PersonRepository extends the JpaRepository interface, that provides us with a lot of operations out-of-the-box, including the standard CRUD operations. You can also add custom operations like findByFirstName and findByLastName without writing any implementation: Spring Data JPA creates them for you!
  • PersonRepository.java
  1. package com.thomasvitale.repository;
  3. import java.util.List;
  5. import org.springframework.data.jpa.repository.JpaRepository;
  6. import org.springframework.stereotype.Repository;
  8. import com.thomasvitale.model.Person;
  10. @Repository
  11. public interface PersonRepository extends JpaRepository<Person, Integer> {
  13. public Person findByFirstName(String firstName);
  14. public List<Person> findByLastName(String lastName);
  16. }
package com.thomasvitale.repository;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.thomasvitale.model.Person;

@Repository
public interface PersonRepository extends JpaRepository<Person, Integer> {
  
  public Person findByFirstName(String firstName);
  public List<Person> findByLastName(String lastName);
  
}

7. Demo

Let’s try some CRUD operations to test our application.
  1. package com.thomasvitale;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.boot.CommandLineRunner;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  8. import com.thomasvitale.model.Person;
  9. import com.thomasvitale.repository.PersonRepository;
  11. @SpringBootApplication
  12. public class Application implements CommandLineRunner {
  14. @Autowired
  15. PersonRepository personRepository;
  17. public static void main(String[] args) {
  18. SpringApplication.run(Application.class, args);
  19. }
  21. @Override
  22. public void run(String... arg0) throws Exception {
  24. // Save three Person documents on PostgreSQL
  25. personRepository.save(new Person("Sheldon", "Cooper"));
  26. personRepository.save(new Person("Missy", "Cooper"));
  27. personRepository.save(new Person("Leonard", "Hofstadter"));
  29. // Get all the people
  30. System.out.println(">>> All the people in the database:");
  31. personRepository.findAll().forEach(System.out::println);
  33. // Get all the people with a specific last name
  34. System.out.println(">>> All people with last name = 'Cooper'");
  35. personRepository.findByLastName("Cooper").forEach(System.out::println);
  37. // Update an individual person
  38. Person person = personRepository.findByFirstName("Sheldon");
  39. person.setFirstName("Shelly");
  40. personRepository.save(person);
  42. // Delete all
  43. personRepository.deleteAll();
  45. }
  46. }
package com.thomasvitale;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.thomasvitale.model.Person;
import com.thomasvitale.repository.PersonRepository;

@SpringBootApplication
public class Application implements CommandLineRunner {
  
  @Autowired
  PersonRepository personRepository;

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }

  @Override
  public void run(String... arg0) throws Exception {
    
      // Save three Person documents on PostgreSQL
      personRepository.save(new Person("Sheldon", "Cooper"));
      personRepository.save(new Person("Missy", "Cooper"));
      personRepository.save(new Person("Leonard", "Hofstadter"));
      
      // Get all the people
      System.out.println(">>> All the people in the database:");
      personRepository.findAll().forEach(System.out::println);
      
      // Get all the people with a specific last name
      System.out.println(">>> All people with last name = 'Cooper'");
      personRepository.findByLastName("Cooper").forEach(System.out::println);
      
      // Update an individual person
      Person person = personRepository.findByFirstName("Sheldon");
      person.setFirstName("Shelly");
      personRepository.save(person);
      
      // Delete all 
      personRepository.deleteAll();
    
  }
}

Resources

FacebookTwitterLinkedInGoogle+PinterestShare

domingo, 10 de septiembre de 2017

Wildfly – Install PostgreSQL JDBC Driver as a Module

  18:02:00   , , , , ,   No comments   Edit
Instead of deploying a JDBC driver with the wildfly auto-deploy feature, the driver can be alternatively installed as an module. This is also necessary to be used with XA-Datasources. So it is a recommended way to install the driver as a module. The following section shows how to a jdbc driver module is created.

Creating a Module

To create a module:
  1. Go to WILDFLY_HOME/modules/system/layers/base/ and create the folder org/postgresql/main;
  2. copy the file postgresql jdbc driver jar file  to the new folderWILDFLY_HOME/modules/system/layers/base/org/postgresql/main
  3. create the file module.xml in the same folder with the following content:
        <?xml version="1.0" encoding="UTF-8"?>
        <module xmlns="urn:jboss:module:1.1" name="org.postgresql">
            <resources>
                <resource-root path="postgresql-9.4.1211.jar"/>
            </resources>
            <dependencies>
                <module name="javax.api"/>
                <module name="javax.transaction.api"/>
            </dependencies>
        </module>
The name of the driver file may vary, so make sure you declare exactly the same name in the resource-root tag. At this point, the module is not available yet. Youneed to reference the module as a driver in WildFly configuration with the following jboss-cli command:
[standalone@localhost:9990 /] /subsystem=datasources/jdbc-driver=postgresql:add(
    driver-name=postgresql,
    driver-module-name=org.postgresql,
    driver-class-name=org.postgresql.Driver
)
The command returns {“outcome” => “success”} in case of success. This command resulted in the following part in the configuration file:
    <datasources>
        {...}
        <drivers>
            {...}
            <driver name="postgresql" module="org.postgresql">
                <driver-class>org.postgresql.Driver</driver-class>
            </driver>
        </drivers>
    </datasources>
It makes the JDBC driver module available for the datasource creation. So a datasource definition can now be defined to use the postgresql driver in the following way:
...
 <datasource ....>
 <connection-url>jdbc:postgresql://localhost/....</connection-url>
 <driver>postgresql</driver>
...

lunes, 20 de febrero de 2017

UTL_MATCH : String Matching by Testing Levels of Similarity/Difference

  15:05:00   , , ,   No comments   Edit


The UTL_MATCH package was introduced in Oracle 10g Release 2, but first documented (and therefore supported) in Oracle 11g Release 2. It contains a variety of functions that are helpful for testing the level of similarity/difference between strings.
Related articles.

Setup

The examples in this article require the following table definition.
DROP TABLE match_tab;

CREATE TABLE match_tab (
  id   NUMBER,
  col1 VARCHAR2(15),
  col2 VARCHAR2(15),
  CONSTRAINT match_tab_pk PRIMARY  KEY (id)
);

INSERT INTO match_tab VALUES (1, 'Peter Parker', 'Pete Parker');
INSERT INTO match_tab VALUES (2, 'Peter Parker', 'peter parker');
INSERT INTO match_tab VALUES (3, 'Clark Kent', 'Claire Kent');
INSERT INTO match_tab VALUES (4, 'Wonder Woman', 'Ponder Woman');
INSERT INTO match_tab VALUES (5, 'Superman', 'Superman');
INSERT INTO match_tab VALUES (6, 'The Hulk', 'Iron Man');
COMMIT;

domingo, 16 de octubre de 2016

Adapter java

  0:56:00   , , , ,   No comments   Edit

Adapter

Busca una manera estandarizada de adaptar un objeto a otro. Se utiliza para transformar una interfaz en otra, de tal modo que una clase que no pudiera utilizar la primera, haga uso de ella a través de la segunda.
Es conocido como Wrapper (al patrón Decorator también se lo llama Wrapper, con lo cual es nombre Wrapper muchas veces se presta a confusión).
Una clase Adapter implementa un interfaz que conoce a sus clientes y proporciona acceso a una instancia de una clase que no conoce a sus clientes, es decir convierte la interfaz de una clase en una interfaz que el cliente espera. Un objeto Adapter proporciona la funcionalidad prometida por un interfaz sin tener que conocer que clase es utilizada para implementar ese interfaz. Permite trabajar juntas a dos clases con interfaces incompatibles.

Este patrón se debe utilizar cuando:
  • Se quiere utilizar una clase que llame a un método a través de una interface, pero se busca utilizarlo con una clase que no implementa ese interface.
  • Se busca determinar dinámicamente que métodos de otros objetos llama un objeto.
  • No se quiere que el objeto llamado tenga conocimientos de la otra clase de objetos.
Este patrón convierte la interfaz de una clase en otra interfaz que el cliente espera. Esto permite a las clases trabajar juntas, lo que de otra manera no podrían hacerlo debido a sus interfaces incompatibles.
Por lo general, esta situación se da porque no es posible modificar la clase original, ya sea porque no se tiene el código fuente de la clase o porque la clase es una clase de propósito general, y es inapropiado para ella implementar un interface par un propósito específico. En resumen, este patrón debe ser aplicado cuando debo transformar una estructura a otra, pero sin tocar la original, ya sea porque no puedo o no quiero cambiarla.

Diagrama UML


Target: define la interfaz específica del dominio que Cliente usa.
Cliente: colabora con la conformación de objetos para la interfaz Target.
Adaptado: define una interfaz existente que necesita adaptarse
Adapter: adapta la interfaz de Adaptee a la interfaz Target
El Cliente llama a las operaciones sobre una instancia Adapter. De hecho, el adaptador llama a las operaciones de Adaptee que llevan a cabo el pedido.

Ejemplo

Vamos a plantear el siguiente escenario: nuestro código tiene una clase Persona (la llamamos PersonaVieja) que se utiliza a lo largo de todo el código y hemos importado un API que también necesita trabajar con una clase Persona (la llamamos PersonaNueva), que si bien son bastante similares tienen ciertas diferencias:
Nosotros trabajamos con los atributos nombre, apellido y fecha de nacimiento.
Sin embargo, la PersonaNueva tiene un solo atributo nombre (que es el nombre y apellido de la persona en cuestión) y la edad actual, en vez de la fecha de nacimiento.

Para esta situación lo ideal es utilizar el Adapter. Para ello primero crearemos las 2 clases de Persona y sus correspondientes interfaces.





 Ahora crearemos al Adapter.

Y se utiliza de esta manera:

Consecuencias
  • El cliente y las clases Adaptee permanecen independientes unas de las otras.
  • Puede hacer que un programa sea menos entendible.
  • Permite que un único Adapter trabaje con muchos Adaptees, es decir, el Adapter por sí mismo y las subclases (si es que la tiene). El Adapter también puede agregar funcionalidad a todos los Adaptees de una sola vez.

Temas a tener en cuenta.
Si bien el Adapter tiene una implementación relativamente sencilla, se puede llevar a cabo con varias técnicas:
1) Creando una nueva clase que será el Adaptador, que extienda del componente existente e implemente la interfaz obligatoria. De este modo tenemos la funcionalidad que queríamos y cumplimos la condición de implementar la interfaz.
2) Pasar una referencia a los objetos cliente como parámetro a los costructores de los objetos adapter o a uno de sus métodos. Esto permite al objeto adapter ser utilizado con cualquier instancia o posiblemente muchas instancias de la clase Adaptee. En este caso particular, el Adapter tiene una implementación casi idéntica al patrón Decorator.
3) Hacer la clase Adapter una clase interna de la clase Adaptee. Esto asume que tenemos acceso al código de dicha clase y que es permitido la modificación de la misma.
4) Utilizar sólo interfaces para la comunicación entre los objetos.

Las opciones más utilizadas son la 1 y la 4.

lunes, 23 de mayo de 2016

Docker 101 Tutorial

  18:58:00   , , ,   No comments   Edit

Docker 101 Tutorial

This is a realistic interactive tutorial for understanding the basics of Docker.
It requires you to successfully complete each minitask, so could be used as an interviewing tool for those that claim to know Docker.
It uses a complete and realistic shell to train you in.
Below is a video showing what it looks like to the user.

Suscribirse a: Entradas (Atom)