{"type":"doc","content":[{"type":"heading","attrs":{"level":3},"content":[{"text":"Java Persistence API","type":"text"}]},{"type":"paragraph","content":[{"text":"The Java Persistence API (JPA) is a specification of Java and it is a standard technology. It is used to persist data between Java object and relational database. JPA acts as a bridge between object-oriented domain models and relational database systems. As JPA is just a specification, it doesn't perform any operation by itself. By itself, JPA is not a tool or framework; rather, it defines a set of concepts that can be implemented by any tool or framework. While JPA's object-relational mapping (ORM) model was originally based on Hibernate, it has since evolved.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"JPA vs Hibernate","type":"text"}]},{"type":"paragraph","content":[{"text":"JPA is a standard, while Hibernate is not. In hibernate, we use Session for handling the persistence of data, while in JPA, we use Entity Manager. The query language in Hibernate is Hibernate Query language, while in JPA, the query language is Java Persistence query language. Hibernate is one of the most JPA providers.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Spring Data JPA","type":"text"}]},{"type":"paragraph","content":[{"text":"Spring Data JPA, part of the larger Spring Data family, makes it easy to easily implement JPA based repositories. This module deals with enhanced support for JPA based data access layers. It makes it easier to build Spring-powered applications that use data access technologies.","type":"text"},{"type":"hardBreak"},{"text":"It provides the following key dependencies:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Hibernate: One of the most popular JPA implementations.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Spring Data JPA: Helps you to implement JPA-based repositories.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Spring ORM: Core ORM support from the Spring Framework.","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Source: ","type":"text"},{"text":"https://spring.io/projects/spring-data-jpa","type":"text","marks":[{"type":"link","attrs":{"href":"https://spring.io/projects/spring-data-jpa"}}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Spring and EclipseLink","type":"text"}]},{"type":"paragraph","content":[{"text":"By default Spring uses Hibernate as the default JPA vendor. Although Hibernate is a good choice, someone may prefers to use EclipseLink as it was supposed to be the reference implementation for the Java Persistence JSR.","type":"text"},{"type":"hardBreak"},{"text":"How configuring Spring-Boot to use EclipseLink as the JPA provider: ","type":"text"},{"text":"https://blog.marcnuri.com/spring-data-jpa-eclipselink-configuring-spring-boot-to-use-eclipselink-as-the-jpa-provider/","type":"text","marks":[{"type":"link","attrs":{"href":"https://blog.marcnuri.com/spring-data-jpa-eclipselink-configuring-spring-boot-to-use-eclipselink-as-the-jpa-provider/"}}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Jakarta Persistence","type":"text"}]},{"type":"paragraph","content":[{"text":"Jakarta Persistence defines a standard for management of persistence and object/relational mapping in Java(R) environments.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Connection Pools","type":"text"}]},{"type":"paragraph","content":[{"text":"A connection pool is a cache of database connections maintained so that the connections can be reused when future requests to the database are required. Connection pools are used to enhance the performance of executing commands on a database. Opening and maintaining a database connection for each user, especially requests made to a dynamic database-driven website application, is costly and wastes resources. In connection pooling, after a connection is created, it is placed in the pool and it is used again so that a new connection does not have to be established. If all the connections are being used, a new connection is made and is added to the pool. Connection pooling also cuts down on the amount of time a user must wait to establish a connection to the database.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"HikariCP","type":"text"}]},{"type":"paragraph","content":[{"text":"HikariCP","type":"text"},{"text":" is a very lightweight (at roughly 130Kb) and lightning-fast JDBC connection pooling framework developed by Brett Wooldridge around 2012. It is a default in SpringBoot.","type":"text"}]},{"type":"paragraph","content":[{"text":"HikariCP-benchmark: ","type":"text"},{"text":"https://github.com/brettwooldridge/HikariCP-benchmark","type":"text","marks":[{"type":"link","attrs":{"href":"https://github.com/brettwooldridge/HikariCP-benchmark"}}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Transaction management","type":"text"}]},{"type":"paragraph","content":[{"text":"Transaction management refers to the tasks of processing multiple transactions issued by various clients of a database server in such a way that the ACID contract can be fulfilled, that is, the properties of atomicity, consistency preservation, isolation, and durability of each individual transaction can be guaranteed. Transaction management is generally understood as requiring serializability-based concurrency control as well as recovery from failures. Concurrency control is the task of scheduling transactions such that their serializability can be guaranteed, while recovery has to restore a consistent database state after a system or media failure. Assuming that the database server is in charge of the “C,” the former guarantees the “I” in ACID, the latter the “A” and “D” properties. Transaction management has to be highly efficient, as modern transaction servers need to accommodate thousands of transactions...","type":"text"}]},{"type":"paragraph","content":[{"text":"The Spring Framework provides a consistent abstraction for transaction management. ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]},{"text":"The Spring Framework’s declarative transaction management is made possible with Spring aspect-oriented programming (AOP), although, as the transactional aspects code comes with the Spring Framework distribution and may be used in a boilerplate fashion, AOP concepts do not generally have to be understood to make effective use of this code.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]}]},{"type":"paragraph","content":[{"text":"Source: ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]},{"text":"https://docs.spring.io/spring-framework/docs/5.3.7/reference/html/data-access.html#transaction","type":"text","marks":[{"type":"link","attrs":{"href":"https://docs.spring.io/spring-framework/docs/5.3.7/reference/html/data-access.html#transaction"}},{"type":"textColor","attrs":{"color":"#333333"}}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Aspect-Oriented Programming","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]}]},{"type":"paragraph","content":[{"text":"Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure. The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. (Such concerns are often termed crosscutting concerns in AOP literature.)","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]},{"type":"hardBreak"},{"text":"One of the key components of Spring is the AOP framework. While the Spring IoC (Inversion of control) container does not depend on AOP, meaning you do not need to use AOP if you don’t want to, AOP complements Spring IoC to provide a very capable middleware solution.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]},{"type":"hardBreak"}]},{"type":"paragraph","content":[{"text":"Source: ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]},{"text":"https://docs.spring.io/spring-framework/docs/5.3.7/reference/html/core.html#aop","type":"text","marks":[{"type":"link","attrs":{"href":"https://docs.spring.io/spring-framework/docs/5.3.7/reference/html/core.html#aop"}},{"type":"textColor","attrs":{"color":"#333333"}}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Use a Higher-level Database Migration Tool","type":"text"}]},{"type":"paragraph","content":[{"text":"Spring Boot supports two higher-level migration tools: Flyway and Liquibase.","type":"text"}]},{"type":"paragraph","content":[{"text":"Example how ","type":"text"},{"text":"how to set things up with ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]},{"text":"Liquibase: ","type":"text"},{"text":"https://github.com/spring-projects/spring-boot/tree/v2.1.18.RELEASE/spring-boot-samples/spring-boot-sample-liquibase","type":"text","marks":[{"type":"link","attrs":{"href":"https://github.com/spring-projects/spring-boot/tree/v2.1.18.RELEASE/spring-boot-samples/spring-boot-sample-liquibase"}}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Policy Framework - Models","type":"text"}]},{"type":"paragraph","content":[{"text":"Models are implemented using Jakarta Persistence. Spring Data JPA needs same implementation.","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"JpaToscaProperty","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"java"},"content":[{"text":"import javax.persistence.Column;\nimport javax.persistence.ElementCollection;\nimport javax.persistence.EmbeddedId;\nimport javax.persistence.Entity;\nimport javax.persistence.Inheritance;\nimport javax.persistence.InheritanceType;\nimport javax.persistence.Table;\n\n\n@Entity\n@Table(name = \"ToscaProperty\")\n@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)\n@Data\n@EqualsAndHashCode(callSuper = false)\npublic class JpaToscaProperty extends PfConcept implements PfAuthorative {\n private static final long serialVersionUID = 1675770231921107988L;\n\n @EmbeddedId\n @VerifyKey\n @NotNull\n private PfReferenceKey key;\n\n @Column\n @VerifyKey\n @NotNull\n private PfConceptKey type;\n\n @Column\n @NotBlank\n private String description;\n\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Spring Repository","type":"text"}]},{"type":"paragraph","content":[{"text":"With Spring Data JPA, is a good choice to implement repositories.","type":"text"},{"type":"hardBreak"},{"text":"The goal of Spring Data repository abstraction is to significantly reduce the amount of boilerplate code required to implement data access layers for various persistence stores.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]}]},{"type":"paragraph","content":[{"text":"Source: ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]},{"text":"https://docs.spring.io/spring-data/data-commons/docs/2.5.1/reference/html/#repositories","type":"text","marks":[{"type":"link","attrs":{"href":"https://docs.spring.io/spring-data/data-commons/docs/2.5.1/reference/html/#repositories"}},{"type":"textColor","attrs":{"color":"#333333"}}]}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"JpaToscaPropertyRepository","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"java"},"content":[{"text":"@Repository\npublic interface JpaToscaPropertyRepository extends JpaRepository {\n\n}\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"and also it needs to implement a JUnit test","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"JpaToscaPropertyRepositoryTest","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"java"},"content":[{"text":"@ExtendWith(SpringExtension.class)\n@DataJpaTest\n@Import(value = ParticipantPolicyParameters.class)\n@TestPropertySource(locations = {\"classpath:application_test.properties\"})\nclass JpaToscaPropertyRepositoryTest {\n\n @Autowired\n private JpaToscaPropertyRepository toscaPropertyRepository;\n\n @Test\n void test() {\n JpaToscaProperty toscaProperty = new JpaToscaProperty();\n PfReferenceKey key = toscaProperty.getKey();\n\n Map metadata = new HashMap<>();\n metadata.put(\"Key\", \"Value\");\n metadata.put(\"K\", \"V\");\n\n List constraints = new ArrayList<>();\n String[] list = new String[] {\"First\", \"Second\"};\n constraints.add(new JpaToscaConstraintValidValues(Stream.of(list).collect(Collectors.toList())));\n\n toscaProperty.setDefaultValue(\"DefaultValue\");\n toscaProperty.setDescription(\"Description\");\n toscaProperty.setRequired(true);\n toscaProperty.setStatus(ToscaProperty.Status.EXPERIMENTAL);\n toscaProperty.setMetadata(metadata);\n toscaProperty.setConstraints(constraints);\n toscaPropertyRepository.save(toscaProperty);\n\n Optional opt = toscaPropertyRepository.findById(key);\n assertThat(opt).isNotEmpty();\n JpaToscaProperty actual = opt.get();\n assertThat(actual.getDefaultValue()).isEqualTo(toscaProperty.getDefaultValue());\n assertThat(actual.getDescription()).isEqualTo(toscaProperty.getDescription());\n assertThat(actual.isRequired()).isEqualTo(toscaProperty.isRequired());\n assertThat(actual.getStatus()).isEqualTo(toscaProperty.getStatus());\n assertThat(actual.getType()).isEqualTo(toscaProperty.getType());\n assertThat(actual.getConstraints()).isEqualTo(toscaProperty.getConstraints());\n }\n}","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Using Dao","type":"text"}]},{"type":"paragraph","content":[{"text":"Dao objects are already implemented in Policy Framework, and there is a way to use them and avoid to create repositories, but It needs to create a new DefaultPfDao class that uses the Entity Manger with no \"begin transaction\" and no \"commit\".","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"DefaultPfDao","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"java"},"content":[{"text":"public class DefaultPfDao implements PfDao {\n private static final Logger LOGGER = LoggerFactory.getLogger(DefaultPfDao.class);\n\n private final EntityManager entityManager;\n\n /**\n * Constructor.\n *\n * @param entityManager EntityManager\n */\n public DefaultPfDao(EntityManager entityManager) {\n this.entityManager = entityManager;\n }\n\n @Override\n public void init(final DaoParameters daoParameters) throws PfModelException {\n // Not need\n }\n\n @Override\n public void create(final T obj) {\n if (obj == null) {\n return;\n }\n entityManager.merge(obj);\n }\n\n @Override\n public void delete(final T obj) {\n entityManager.remove(entityManager.contains(obj) ? obj : entityManager.merge(obj));\n }\n\n","type":"text"}]},{"type":"paragraph","content":[{"type":"hardBreak"}]},{"type":"paragraph","content":[{"text":"EntityManager is not thread safe, and it need to use @PersistenceContext annotation, so Spring will inject a","type":"text"},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"thread-safe proxy for the actual transactional EntityManager.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"PolicyModelsProviderImpl","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"java"},"content":[{"text":"@Service\n@Transactional\npublic class PolicyModelsProviderImpl implements PolicyModelsProvider {\n\n @PersistenceContext\n private EntityManager entityManager;\n\n @Override\n public ToscaServiceTemplate createServiceTemplate(@NonNull ToscaServiceTemplate serviceTemplate) {\n LOGGER.debug(\"->createServiceTemplate: serviceTemplate={}\", serviceTemplate);\n try {\n\n ToscaServiceTemplate createdServiceTemplate =\n new SimpleToscaProvider().appendToServiceTemplate(new DefaultPfDao(entityManager),\n new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();\n\n LOGGER.debug(\"<-createServiceTemplate: createdServiceTemplate={}\", createdServiceTemplate);\n return createdServiceTemplate;\n } catch (Exception pfme) {\n throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, pfme.getMessage(), pfme);\n }\n }\n\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Spring Service","type":"text"}]},{"type":"paragraph","content":[{"text":"Example how to convert ControlLoopInstantiationProvider class in Spring style using \"@Service\" and \"@Transactional\"","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"ControlLoopInstantiationProvider","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"java"},"content":[{"text":"@Service\npublic class ControlLoopInstantiationProvider {\n private final ControlLoopProvider controlLoopProvider;\n private final CommissioningProvider commissioningProvider;\n\n /**\n * Create a instantiation provider.\n *\n * @param databaseProviderParameters the parameters for database access\n */\n public ControlLoopInstantiationProvider(ControlLoopProvider controlLoopProvider,\n CommissioningProvider commissioningProvider) {\n this.controlLoopProvider = controlLoopProvider;\n this.commissioningProvider = commissioningProvider;\n }\n\n @Transactional\n public InstantiationResponse createControlLoops(ControlLoops controlLoops) throws PfModelException {\n for (ControlLoop controlLoop : controlLoops.getControlLoopList()) {\n ControlLoop checkControlLoop = controlLoopProvider.getControlLoop(controlLoop.getKey().asIdentifier());\n if (checkControlLoop != null) {\n throw new PfModelException(Response.Status.BAD_REQUEST,\n controlLoop.getKey().asIdentifier() + \" already defined\");\n }\n }\n BeanValidationResult validationResult = validateControlLoops(controlLoops);\n if (!validationResult.isValid()) {\n throw new PfModelException(Response.Status.BAD_REQUEST, validationResult.getResult());\n }\n controlLoopProvider.createControlLoops(controlLoops.getControlLoopList());\n\n InstantiationResponse response = new InstantiationResponse();\n response.setAffectedControlLoops(controlLoops.getControlLoopList().stream()\n .map(cl -> cl.getKey().asIdentifier()).collect(Collectors.toList()));\n\n return response;\n }\n\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Transaction","type":"text"}]},{"type":"paragraph","content":[{"text":"Transaction Propagation in SpringBoot:","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"REQUIRED","type":"text","marks":[{"type":"strong"},{"type":"textColor","attrs":{"color":"#242729"}}]},{"text":" ","type":"text","marks":[{"type":"strong"},{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"is the ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"default propagation","type":"text","marks":[{"type":"underline"},{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":". Spring checks if there is an active transaction, then it creates a new one if nothing existed;","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"For","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"SUPPORTS","type":"text","marks":[{"type":"strong"},{"type":"textColor","attrs":{"color":"#242729"}}]},{"text":", Spring first checks if an active transaction exists. If a transaction exists, then the existing transaction will be used. If there isn't a transaction, it is executed non-transactional;","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"When the propagation is","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"MANDATORY","type":"text","marks":[{"type":"strong"},{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":", if there is an active transaction, then it will be used. If there isn't an active transaction, then Spring throws an exception;","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"For transactional logic with","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"NEVER ","type":"text","marks":[{"type":"strong"},{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"propagation, Spring throws an exception if there's an active transaction;","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"NOT_SUPPORTED","type":"text","marks":[{"type":"strong"},{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":", Spring at first suspends the current transaction if it exists, then the business logic is executed without a transaction;","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"When the propagation is","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"REQUIRES_NEW","type":"text","marks":[{"type":"strong"},{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":", Spring suspends the current transaction if it exists and then creates a new one.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]}]}]},{"type":"paragraph","content":[{"text":"Read only Transaction ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}},{"type":"strong"}]}]},{"type":"paragraph","content":[{"text":"If the transaction is effectively read-only, it allows for corresponding optimizations at runtime. (","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"https://stackoverflow.com/questions/1614139/spring-transactional-read-only-propagation","type":"text","marks":[{"type":"link","attrs":{"href":"https://stackoverflow.com/questions/1614139/spring-transactional-read-only-propagation"}},{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":")","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"paragraph","content":[{"type":"hardBreak"}]},{"type":"paragraph","content":[{"text":"Note","type":"text","marks":[{"type":"strong"},{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":": ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"In Spring,","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"@Transactional","type":"text","marks":[{"type":"code"}]},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"works by creating a proxy of the class and intercepting the annotated method (AOP Proxies). This means that","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"@Transactional","type":"text","marks":[{"type":"code"}]},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"doesn't work if you are calling the annotated method from another method of the same class. ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Other links","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"https://gerrit.nordix.org/c/local/onap/clamp-pilot/+/8929","type":"text","marks":[{"type":"link","attrs":{"href":"https://gerrit.nordix.org/c/local/onap/clamp-pilot/+/8929"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/","type":"text","marks":[{"type":"link","attrs":{"href":"https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"https://docs.spring.io/spring-framework/docs/current/reference/html/","type":"text","marks":[{"type":"link","attrs":{"href":"https://docs.spring.io/spring-framework/docs/current/reference/html/"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"https://www.adam-bien.com/roller/abien/entry/jpa_ejb3_killed_the_dao","type":"text","marks":[{"type":"link","attrs":{"href":"https://www.adam-bien.com/roller/abien/entry/jpa_ejb3_killed_the_dao"}}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"https://www.adam-bien.com/roller/abien/entry/daos_aren_t_dead_but","type":"text","marks":[{"type":"link","attrs":{"href":"https://www.adam-bien.com/roller/abien/entry/daos_aren_t_dead_but"}}]}]}]}]},{"type":"paragraph","content":[{"type":"hardBreak"}]}],"version":1}

Browser not supported