From [Spring Data JPA - Reference Documentation][1],

Limiting query results
---
The results of query methods can be limited via the keywords `first` or `top`, which can be used interchangeably. An optional numeric value can be appended to `top/first` to specify the maximum result size to be returned. If the number is left out, a result size of 1 is assumed.

Limiting the result size of a query with Top and First
---

    User findFirstByOrderByLastnameAsc();
    
    User findTopByOrderByAgeDesc();
    
    Page&lt;User&gt; queryFirst10ByLastname(String lastname, Pageable pageable);
    
    Slice&lt;User&gt; findTop3ByLastname(String lastname, Pageable pageable);
    
    List&lt;User&gt; findFirst10ByLastname(String lastname, Sort sort);

    List&lt;User&gt; findTop10ByLastname(String lastname, Pageable pageable);

The limiting expressions also support the `Distinct` keyword. Also, for the queries limiting the result set to one instance, wrapping the result into an Optional is supported.


  [1]: http://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.limit-query-result

Angular2 removes `&lt;script&gt;` tags automatically from templates to stop people using this functionality as a [&quot;poor&#39;s man&quot; loader][1].

The issue here is that script tags currently have more uses than just loading code or other script files. There is the possibility that further functionality around `&lt;script&gt;` tags will be introduced in future as well.

One current use is JSON-LD which takes the format 

    &lt;script type=&quot;application/ld+json&quot;&gt;
    {
        &quot;@context&quot;:&quot;http://schema.org&quot;,
        &quot;@type&quot;:&quot;HealthClub&quot;,
        ...
    }
    &lt;/script&gt;

A commonly suggested work around is to [dynamically add script tags][2] to the document via the `ngAfterViewInit` hook, but this is obviously not proper ng2 practice and will not work server side, which JSON-LD obviously needs to be able to do.

Are there any other workarounds that we can use to include `&lt;script&gt;` tags in angular2 templates (even if the tag is inert within the browser) or is this a case of the framework being too opinionated? What other solutions might exist if this situation can&#39;t be solved in angular2?

  [1]: https://github.com/angular/angular/issues/2766#issuecomment-128005280
  [2]: https://stackoverflow.com/a/35570910/981598

Adding script tags in Angular component template

I&#39;m working with Webpack and Visual Studio Code and in order to avoid things like:

    import { AuthenticationService } from &#39;../../../services/authentication/service&#39;;

I&#39;ve created aliases on my webpack.config so I can use:

    import { AuthenticationService } from &#39;services/authentication/service&#39;;
However, by doing so Visual Code is not able to detected my code and therefore I lose the intelisense for my classes.

Does anyone have a solution for that, is there a way to make VS code to read the webpack.config and recognize the path with the alias?

thanks in advance  

Make VS code read webpack.config and recognize path with alias?

I recently started working with Spring data jpa. 

It would be highly appreciable if somebody could throw some light on the ***technical differences*** between **Spring Data JPA&#39;s** `findFirst` and `findTop`. 

Differences, usages. 


Thanks

Technical differences between Spring Data JPA&#39;s findFirst and findTop

I recently started working with Spring data jpa.
It would be highly appreciable if somebody could throw some light on the technical differences between Spring Data JPA's <code>findFirst</code> and <code>findTop</code>.
Differences, usages.
Thanks

I need to list all files contained in a certain folder contained in my S3 bucket.

The folder structure is the following

    /my-bucket/users/&lt;user-id&gt;/contacts/&lt;contact-id&gt;

I have files related to users and files related to a certain user&#39;s contact.
I need to list both.

To list files I&#39;m using this code:

    ListObjectsRequest listObjectsRequest = new ListObjectsRequest().withBucketName(&quot;my-bucket&quot;)
    				.withPrefix(&quot;some-prefix&quot;).withDelimiter(&quot;/&quot;);
    ObjectListing objects = transferManager.getAmazonS3Client().listObjects(listObjectsRequest);

To list a certain user&#39;s files I&#39;m using this prefix: 

`users/&lt;user-id&gt;/` 

and I&#39;m correctly getting all files in the directory excluding `contacts` subdirectory, for example:

    users/&lt;user-id&gt;/file1.txt
    users/&lt;user-id&gt;/file2.txt
    users/&lt;user-id&gt;/file3.txt

To list a certain user contact&#39;s files instead I&#39;m using this prefix: 

`users/&lt;user-id&gt;/contacts/&lt;contact-id&gt;/`

but in this case I&#39;m getting also the 
directory itself as a returned object:

    users/&lt;user-id&gt;/contacts/&lt;contact-id&gt;/file1.txt
    users/&lt;user-id&gt;/contacts/&lt;contact-id&gt;/file2.txt
    users/&lt;user-id&gt;/contacts/&lt;contact-id&gt;/

Why am I getting this behaviour? What&#39;s different beetween the two listing requests? I need to list only files in the directory, excluding sub-directories.

Listing files in a specific &quot;folder&quot; of a AWS S3 bucket

In Swagger, the [`@Api`](https://www.javadoc.io/static/io.swagger/swagger-annotations/1.6.2/io/swagger/annotations/Api.html) annotation&#39;s [`description`](https://www.javadoc.io/static/io.swagger/swagger-annotations/1.6.2/io/swagger/annotations/Api.html#description--) element is deprecated.

&gt; **Deprecated.**
&gt; Not used in 1.5.X, kept for legacy support.

Is there a newer way of providing the description?

Api annotation&#39;s description is deprecated

Let&#39;s say I&#39;m writing a method that should return a [Map][1]. For instance:

    public Map&lt;String, Integer&gt; foo() {
      return new HashMap&lt;String, Integer&gt;();
    }

After thinking about it for a while, I&#39;ve decided that there is no reason to modify this Map once it is created. Thus, I would like to return an [ImmutableMap][2].

    public Map&lt;String, Integer&gt; foo() {
      return ImmutableMap.of();
    }

&lt;b&gt; Should I leave the return type as a generic Map, or should I specify that I&#39;m returning an ImmutableMap ? &lt;/b&gt;
&lt;br&gt;&lt;br&gt;
From one side, this is exactly why interfaces were created for; to hide the implementation details.
&lt;br&gt; 
On the other hand, if I&#39;ll leave it like this, other developers might miss the fact that this object is immutable. Thus, I won&#39;t achieve a major goal of immutable objects; to make the code more clear by minimizing the number of objects that can change. Even worst, after a while, someone might try to change this object, and this will result in a runtime error (The compiler will not warn about it).

  [1]: https://docs.oracle.com/javase/7/docs/api/java/util/Map.html
  [2]: https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/ImmutableMap.html

Is it better to return an ImmutableMap or a Map?

I have written simple rest application using Spring MVC 4 (or Spring-Boot). Within the controller I have return `ResponseEntity`. But in some cases I want to give success JSON and if there is validation error I want to give error JSON. Currently success and error responses are totally different, So I have created 2 classes for error and success. Within the controller I want to return `ResponseEntity&lt;Success&gt;` , if the internal logic is okay. Otherwise  I want to return `ResponseEntity&lt;Error&gt;`. Is there any way to do it.

`Success` and `Error` are the 2 classes that i use to represent success and error response.


What is the best way to return different types of ResponseEntity in Spring MVC or Spring-Boot

I convert one of my Java class to Kotlin and the class as below.

    class MainApplication : Application() {
        companion object {
            operator fun get(context: Context): MainApplication {
                return context.applicationContext as MainApplication
            }
        }
    }

It has a static function `get`.

I still have a Java function accessing it.

    MainApplication application = MainApplication.get(mContext);

It was good when MainApplication is in Java. But not when MainApplication in Kotlin, the above code error

    Error:(27, 54) error: cannot find symbol method get(Context)

How could I access `get` in my Java code above?

How to access Kotlin companion object in Java?

In a web project, using latest spring-data (1.10.2) with a MySQL 5.6 database, I&#39;m trying to use a native query with pagination but I&#39;m experiencing an `org.springframework.data.jpa.repository.query.InvalidJpaQueryMethodException` at startup. 

**UPDATE**: 20180306 This issue is now fixed in [Spring 2.0.4][1] For those still interested or stuck with older versions check the related answers and comments for workarounds.
--------

According to [Example 50 at Using @Query from spring-data documentation][2] this is possible specifying the query itself and a countQuery, like this:

    public interface UserRepository extends JpaRepository&lt;User, Long&gt; {
      @Query(value = &quot;SELECT * FROM USERS WHERE LASTNAME = ?1&quot;,
        countQuery = &quot;SELECT count(*) FROM USERS WHERE LASTNAME = ?1&quot;,
        nativeQuery = true)
      Page&lt;User&gt; findByLastname(String lastname, Pageable pageable);
    }

Out of curiosity, In `NativeJpaQuery` class I can see that it contains the following code to check if it&#39;s a valid jpa query:

    public NativeJpaQuery(JpaQueryMethod method, EntityManager em, String queryString, EvaluationContextProvider evaluationContextProvider, SpelExpressionParser parser) {
       super(method, em, queryString, evaluationContextProvider, parser);
       JpaParameters parameters = method.getParameters();
       boolean hasPagingOrSortingParameter = parameters.hasPageableParameter() || parameters.hasSortParameter();
       boolean containsPageableOrSortInQueryExpression = queryString.contains(&quot;#pageable&quot;) || queryString.contains(&quot;#sort&quot;);
       if(hasPagingOrSortingParameter &amp;&amp; !containsPageableOrSortInQueryExpression) {
           throw new InvalidJpaQueryMethodException(&quot;Cannot use native queries with dynamic sorting and/or pagination in method &quot; + method);
       }
    }

My query contains a `Pageable` parameter, so `hasPagingOrSortingParameter` is `true`, but it&#39;s also looking for a `#pageable` or `#sort` sequence inside the `queryString`, which I do not provide.

I&#39;ve tried adding `#pageable` (it&#39;s a comment) at the end of my query, which makes validation to pass but then, it fails at execution saying that the query expects one additional parameter: 3 instead of 2.

Funny thing is that, if I manually change `containsPageableOrSortInQueryExpression` from `false` to `true` while running, the query works fine so I don&#39;t know why it&#39;s checking for that string to be at my `queryString` and I don&#39;t know how to provide it.

Any help would be much appreciated.

*Update 01/30/2018*
It seems that developers at spring-data project are working on a fix for this issue with a [PR by Jens Schauder][3]


  [1]: https://jira.spring.io/browse/DATAJPA/fixforversion/16650/?selectedTab=com.atlassian.jira.plugins.jira-development-integration-plugin:release-report-tabpanel
  [2]: http://docs.spring.io/spring-data/jpa/docs/current/reference/html/#jpa.query-methods.at-query
  [3]: https://github.com/spring-projects/spring-data-jpa/pull/246

Spring Data and Native Query with pagination

So I have looked at various tutorials about JPA with Spring Data and this has been done different on many occasions and I am no quite sure what the correct approach is.

Assume there is the follwing entity:

    package stackoverflowTest.dao;

    import javax.persistence.*;

    @Entity
    @Table(name = &quot;customers&quot;)
    public class Customer {
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = &quot;id&quot;)
    private long id;

    @Column(name = &quot;name&quot;)
    private String name;

    public Customer(String name) {
        this.name = name;
    }

    public Customer() {
    }

    public long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    }


We also have a DTO which is retrieved in the service layer and then handed to the controller/client side.

    package stackoverflowTest.dto;

    public class CustomerDto {
    
    private long id;
    private String name;

    public CustomerDto(long id, String name) {
        this.id = id;
        this.name = name;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    }


So now assume the Customer wants to change his name in the webui - then there will be some controller action, where there will be the updated DTO with the old ID and the new name.

Now I have to save this updated DTO to the database.


Unluckily currently there is no way to update an existing customer (except than deleting the entry in the DB and creating a new Cusomter with a new auto-generated id)

However as this is not feasible (especially considering such an entity could have hundreds of relations potentially) - so there come 2 straight forward solutions to my mind:

1. make a setter for the id in the Customer class - and thus allow setting of the id and then save the Customer object via the corresponding repository.

or

2. add the id field to the constructor and whenever you want to update a customer you always create a new object with the old id, but the new values for the other fields (in this case only the name)

So my question is wether there is a general rule how to do this?
Any maybe what the drawbacks of the 2 methods I explained are?

How to beautifully update a JPA entity in Spring Data?

I have this model:

    public class Event {
    	private String name;
    	private Date start;
    	private Date end;
    }

and repository as

    @Repository
    public interface EventRepository extends JpaRepository&lt;Event, Long&gt; {
    	List&lt;Event&gt; findByEventTypeAccount(Account account);
    }

What I want to do is, I will pass one date and need to check that date is between `start` and `end` e.g. (I will pass Sept 30 as date and need to find all entries which have Sept 30 between their `start` and `end`)

Something like `findDateisBetweenStartAndEnd(Date date)`?

Check date between two other dates spring data jpa

I am using Spring Boot 1.4.1 which uses Hibernate 5.0.11.  Initially I configured a data source using `application.properties` like this:

    spring.datasource.uncle.url=jdbc:jtds:sqlserver://hostname:port/db
    spring.datasource.uncle.username=user
    spring.datasource.uncle.password=password
    spring.datasource.uncle.dialect=org.hibernate.dialect.SQLServer2012Dialect
    spring.datasource.uncle.driverClassName=net.sourceforge.jtds.jdbc.Driver

I configured it with &quot;uncle&quot; because that will be the name of one of multiple data sources that I&#39;ll configure.  I configured this data source like this, according to the Spring docs:

	@Bean
	@Primary
	@ConfigurationProperties(prefix = &quot;spring.datasource.uncle&quot;)
	public DataSource uncleDataSource() {
		return DataSourceBuilder.create().build();
	}

At this point everything worked fine.  

I created an `@Entity` class without any `@Column` annotations and let Hibernate figure out the column names, for example if I have a Java property named `idBank`, Hibernate will automatically assume the column name is `id_bank`.  This is used when generating ddl, running SQL statements, etc.  I want to utilize this feature because I&#39;m going to have a lot of entity classes and don&#39;t want to have to create and maintain all of the @Column annotations.  At this point, this worked fine.

I then added another data source like this:

    spring.datasource.aunt.url=jdbc:sybase:Tds:host2:port/db2
    spring.datasource.aunt.username=user2
    spring.datasource.aunt.password=password2
    spring.datasource.aunt.dialect=org.hibernate.dialect.SybaseDialect
    spring.datasource.aunt.driverClassName=com.sybase.jdbc4.jdbc.SybDriver

... and also this, following the Spring docs for setting up multiple data sources.  Apparently once you define a 2nd data source, it can&#39;t configure the default beans and you have to define your own `EntityManager` and `TransactionManager`.  So in addition to the data source configured above, I added these configurations:

	@Bean
	@Primary
    PlatformTransactionManager uncleTransactionManager(@Qualifier(&quot;uncleEntityManagerFactory&quot;) final EntityManagerFactory factory) {
		return new JpaTransactionManager(factory);
	}

	@Bean
	@Primary
	LocalContainerEntityManagerFactoryBean uncleEntityManagerFactory(
            EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(uncleDataSource())
                .packages(Uncle.class)
                .persistenceUnit(&quot;uncle&quot;)
                .build();
	}

    @Bean
    @ConfigurationProperties(prefix = &quot;spring.datasource.aunt&quot;)
    public DataSource auntDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    PlatformTransactionManager auntTransactionManager(@Qualifier(&quot;auntEntityManagerFactory&quot;) final EntityManagerFactory factory) {
        return new JpaTransactionManager(factory);
    }

    @Bean
    LocalContainerEntityManagerFactoryBean auntEntityManagerFactory(
            EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(auntDataSource())
                .packages(Aunt.class)
                .persistenceUnit(&quot;aunt&quot;)
                .build();
    }

This works in terms of connecting to the database and trying to fetch data.

**HOWEVER** (and here&#39;s the problem, thanks for reading this far).  After these configurations I have lost the implied naming strategy that translates Java column names to snake case names, so now if I have a Java property `idBank` it incorrectly uses column name `idBank` instead of `id_bank`.  I would really like to get that functionality back.

There is a JPA property for this `spring.jpa.hibernate.naming-strategy`, and there are various naming strategy classes in Spring and Hibernate such as `org.springframework.boot.orm.jpa.hibernate.SpringNamingStrategy`.  So I tried setting it like this:

    spring.jpa.hibernate.naming_strategy=org.springframework.boot.orm.jpa.hibernate.SpringNamingStrategy

But it did not work. I tried some variations such as:

    spring.datasource.uncle.naming_strategy=org.springframework.boot.orm.jpa.hibernate.SpringNamingStrategy

and

    spring.datasource.uncle.hibernate.naming_strategy=org.springframework.boot.orm.jpa.hibernate.SpringNamingStrategy

but this did not have any effect.

Then I read that in Hibernate 5, the naming strategy was broken up into two parts, &quot;physical&quot; and &quot;implicit&quot; and there are different settings for each.  So I tried this, with a few variations:

    spring.jpa.hibernate.naming.physical-strategy=org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy

and

    spring.jpa.hibernate.naming.implicit-strategy=org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy

and

    spring.datasource.uncle.naming.physical-strategy=org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy

and

    spring.datasource.uncle.hibernate.naming.implicit-strategy=org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy

But none of these worked.

It seems like there should be a way for me to set this configuration in the beans directly, such as on the `SessionFactory`, but I could not find that API. The documentation around this seems to have some gaps.

I&#39;d really like to avoid setting up a `persistence.xml` also, which I have not needed up to this point.

So here is where I&#39;m stuck and I&#39;m hoping someone can help out.  Really what I would like is a way to debug these property settings, I turned on trace logging in both `org.springframework` and `org.hibernate` but there was nothing useful there.  I tried stepping through the code when these beans were configured but couldn&#39;t find the place where this happens.  If anyone has that info and could share it I&#39;d be really grateful.

Can&#39;t set JPA naming strategy after configuring multiple data sources (Spring 1.4.1 / Hibernate 5.x)

for example I have a method in my CRUD interface which deletes a user from the database:

    public interface CrudUserRepository extends JpaRepository&lt;User, Integer&gt; {

        @Transactional
        @Modifying
        @Query(&quot;DELETE FROM User u WHERE u.id=:id&quot;)
        int delete(@Param(&quot;id&quot;) int id, @Param(&quot;userId&quot;) int userId);
    }
This method will work only with the annotation @Modifying. But what is the need for the annotation here? Why cant spring analyze the query and understand that it is a modifying query?

Content Type	Original Author	Original Content on Stackoverflow
Question	Abdullah Khan	View Question on Stackoverflow
Solution 1 - Java	SkyWalker	View Answer on Stackoverflow

Technical differences between Spring Data JPA's findFirst and findTop

Java Problem Overview

Java Solutions

Solution 1 - Java

Limiting query results

Limiting the result size of a query with Top and First

Make VS code read webpack.config and recognize path with alias?

Adding script tags in Angular component template

Attributions