Jakarta EE Tech Talks, 10 May 2021

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: JPAstreamer: Expressing Hibernate/JPA queries with Java streams | Jakarta Tech Talks | May 10, 2021

Description

Per-Åke Minborg - Founder and CTO of Speedment, Inc presents:

What if you could keep Hibernate/JPA and at the same time stick to Java and the Java Stream API?

Like many Java developers, I like to stick to a single language. Every time I come across a database project and need to switch from Java to Hibernate Query Language (HQL) or Java Persistence Query Language (JPQL), it is a tedious process because the syntax is wordy and partly unintuitive. Nevertheless, I do appreciate that the Hibernate Java Persistence API (JPA) abstracts away other inconveniences for me.

Now, you might think that it’s already possible to obtain streams in the later versions of JPA, and this is perfectly true. However, those streams fall short of enabling the use of streams to express actual database queries. This feature merely relies on a wrapped stream from previous HQL or JPQL queries or users performing complete table scans. To add insult to injury, these stream implementations are often flawed and perform poorly.

To solve these problems, Speedment developed the open source library called JPAstreamer. This webinar shows how to express JPA, Hibernate, and Spring queries using standard Java streams. All that is necessary is to add a single dependency, and then the application is instantly ready to handle database Java streams.

Get Social!

Website: jakarta.ee
Subscribe: https://www.youtube.com/user/EclipseF...
Follow us on Twitter: https://twitter.com/JakartaEE
Like us on Facebook: https://www.facebook.com/JakartaEE/...
Join us on LinkedIn: https://www.linkedin.com/groups/13597...
Tag us: #JakartaEE
Want more great Eclipse Community webinars? Become a member of our Jakarta Tech Talks Meetup: https://www.meetup.com/jakartatechtalks

A

Hello, everybody and welcome to another jakarta tech talk I am thrilled today to have joining us permanent borg. Founder of ct, founder and cto at speedment per today, is presenting jpa streamer expressing hibernate jpa queries with java streams per is a passionate java developer, dedicated to open source software and an expert in finding new ways of solving problems, the harder the problem the better.

A

As a result, he has over 15 us patents, u.s patent applications and invention disclosures and a deep understanding of in-memory databases, high-performance solutions, cloud technologies and concurrent programming per is also a regular speaker, conferences and java events all over the world without any further delay. I'll turn it over to you pair. Take it away.

B

Okay, thank you for this comprehensive introduction. So I actually my next slide is about myself, but I guess I have to just skip that. So I'm going to talk about jpa streamer and this is a descriptive name.

B

So it's about streaming, creating streams with jpi and expressing your credits, not just getting a stream but expressing streams with the the job streams. So, let's, um let's skip this picture. uh I've been around since java, 1.0, that's many more cycles ago, so the talk is divided into two separate sections: sections one is the actual presentation and one is a live code demo and I actually like live code demos generally, more than just a presentation, so I don't know about you, but if you like one thing or the other, it doesn't matter something for here.

B

Nothing for you, anyhow! So what's the problem! uh Well, I like jpa and hibernate. It provides a nice way to abstract away inconveniences, but I really I'm really like java more. I love java and I like the java stream api. So this is kind of gives me a bit of a problem, because I need to mix hibernate queries and to get kind of java streams. When I'm I'm typing, writing my queries and it's not completely tie safe or it's not intuitive at all.

B

So I have to switch back and forth between these different concepts of sql and java, and it's kind of this annoying impedance mismatch between them. So that's where we started we were thinking. Can we do this in a better way and you might think now that isn't it possible to obtain streams from from jpa as it is, and in fact it is, you can write an expression and then, for example, using sql and then get the stream. But you can't express your query as a stream.

B

That's the big difference and I think you're going to understand what I mean with express as the presentation progresses.

B

So, what's strawberry there in jpa is kind of relies on a wrap stream from the previous sql query or or something else that you do, and sometimes it's even a user performing a complete table scan and, um as a matter of fact, the default implementation for for the stream operation is actually to materialize everything from the query into a list and then only after that invoke a stream and that's, of course, a disaster in terms of of performance and also memory usage and, and that would avoid things even worse.

B

The implementation of this stream sometimes is flawed. Also, so, let's see uh what is java stream api? Well, I think it's very efficient and ters and type safe, and it's very intuitive to express application logic with with java streams and if we just add jpa streamer, you can add all these features to your jpa application.

B

You get the same features as the java stream api, basically by just having a single dependency in your application. So this is a video and just before the presentation, I was told that you're not going to hear the audio of this video. That's unfortunate because I think the voice in the in the video is it's better than mine, but anyway you have to stick to to my voice here. So I'm going around this I'm trying to talk simultaneously uh well, I was supposed to do that.

B

So, let's see what happens here so the api stream is it's a great tool to express queries using jp using java strings. So, for example, if you have an example using hibernate, you can add a single dependency and then your application instantly can use javascript.

B

So here's an example, so I can instantiate my jpa streamer like this or I can auto wire it using spring and once I've done this, I can easily stream a row in a database like this. I apply python over operations like this and the queries are kind of easy to see here. What does and I can I can leverage code completion here and I see what kind of columns I have here and what I can apply and in this case I added the filter here.

B

So these are also automatically optimized to use sql under the hood, so it will kind of create a sql query here.

B

So in this way you can boost your development uh instead of spending time with debugging, and you can go to jpastream.org and see how you can install this single dependency here and unfortunately, you missed all the nice cool sound effects in this video. I couldn't do them as I spoke, so I encourage you to go there and watch the re film after the presentation anyways. So this is a comparison between three different ways of writing: a kind of spring or or a kind of a query.

B

So, on the left hand, side we are using jba criteria builder in the middle. We have a spring data jpi and at the right hand, side on the right hand, side we have the jpa streamer and I will not dive into the details, but you can see that this is quite compact and small compared to especially using the jbi criteria builder here, so it provides a nice mean a nice way of keeping your code clean and kind of easy to to understand.

B

I mean also most of the times your code is actually read rather than written. So once you have written this, I think it's very easy to understand the intention of all this.

B

So there are examples in literature when, when there are more than 100 times more reads than rights of developers in code, so I think that's a very important perspective to have when you write code, it should be easy to to be understood.

B

So, let's take a little bit more deep down into this. It's a declarative style like like uh streams, so it's shorter code, improved readability and improved code metrics. So the complexity of this method, when you run static code analysis, for example, is much less than the other examples we've shown on the previous page. It's also completely type safe.

B

Admittedly, you have a partially type safe when using criteria builders, but it's not entirely type safe, but this is entirely type safe and it's possible to detect errors once you're developing and it will improve your code quality and it will ultimately save you time not only when you're developing, but especially for code maintenance.

B

So this is basically jpa streamer in a nutshell, and when I was asked to have this presentation, it should take about an hour and actually the apa stream is it's only about this stream overload method, which is just one overload. It's just a jpa, streamer stream, that's basically what it does, and so I was kind of uh oh how I'm going to talk about this for one hour, but let's see how how long time this will take.

B

So this is an example. I I use the jpa streamer instance here and say that I want to stream of user users here and users here is a jpa entity class that is very important to understand. I can't just put into their stream or something else here then jpa streamer wouldn't understand. This must be something that is a jpa entity.

B

In this case, I'm filtering out all the users for the first name starts with an a then I sort them using the last name in reverse order, I'm only interested in the first 10 of those and then I'm going to print them out on on the console like this, you might wonder what this user dollar is, and I will tell you about this a little bit later.

B

However, when you start to think about this, you might think that wow, this doesn't seem very performance um kind of friendly, because it looks like everything the entire table is going to be pulled in into the jvm and and then we're going to compare all those millions of users if they start with a and then maybe there are tenants or twenty thousand, let's start with an a so we're gonna sort all them and then just have a look at ten of them that that doesn't sound efficient, but that's not the way it works.

B

The cool thing is that jpa streamer is able to introspect its own pipeline. So these operations here, which are circled with the red they are called intermediate operators, and this last one. This is a terminal operator.

B

So when when the stream will reach its terminal operator, it will before it's doing what it's supposed to do. It's going to inspect its own pipeline and see, which are these operation can unmerge into a sql query, and it will start here and look at the filter and see that wow. I can recognize this this credit card here this this credit card here is actually populated with the metadata.

B

That is enough for me to to extract this predicate and merge it into the sql query, and actually the same is true for the sorted one, because I this predicate here or this, this column name has enough metadata to be merged into sql and also this third operation here limit 10 can also be merged into sql data.

B

So this will look like something like this. This stream will be kind of collapsed into this sql query: select user from user, where first name equals to whatever parameter I had and using this order here, last name descending.

B

So that's quite cool, so so what we will be doing in reality is that we will have jpa streamer issue. This query, query select from user and this will be executed in the database and the last section here in the terminal operator will be executed in the jvm, and this is all under the hood. You don't have to think about this. This is happening all automatically.

B

So how is this possible? Well, jpa stream is using an annotation processor to form this metadata model. uh The metadata is this class with a dollar at the end, so it will kind of see all the entities you have on your class path and we will generate generate the corresponding method at the class for that type class and for and that is also used for all the columns.

B

So all the columns have predicates like this, and it also depends what kind of column it is so, depending on what kind of column it is, you will have different kind of predicates here, for example, if it's an integer, you might have some of them, but if it's string, you might have other operators here, and these predicates here can all be used by by the jpa stream. It's query optimizer, so that's quite cool, so let's take a deeper look into what an entity actually might look like.

B

So this is a an example of a user entity declared in jpa, and I haven't changed anything here. This is a completely normal jpa declaration or a clause, so we don't have to do anything with the existing code. We have, we can use it as it is so here we have, for example, user id, which is kind of I guess it's an integer very first name and a last name. We have a bunch of other properties here too. That's not seen on this on this screen here.

B

So jpi statement does not alter or disturb the existing code base. It just adds the ability to handle java stream queries from this point forward. Everything you had before will still work as it used to do. This is just a small thing layer on top of jpa that you add, and the metadata model by default is placed in the generated sources subfolder.

B

You can also set this to another folder if you'd like to, for example, check in this code for some reason so what's required to use jpa streamer. Well, obviously, you have to have java 8, because streams were only introduced in your weights, but you can use any version of java higher than eight or higher.

B

Of course, you also need a jpa provider like hibernate and hibernate is the most common one, but there are also certainly others like eclipse link. The objective of jpa streamer were never to replace a jpi provider. It's just adding things on top of an existing jpa provider.

B

You can download from github or you can just add a single dependency and you may have an upgraded build and the metadata models are generated as byte code from the existing gpa entities and the source code. Of course you can. You can also inspect that and look how how it works and all that stuff. So there is nothing secret here. It's nothing magic going on it's just pure java.

B

Okay, so how do we do this? Well, as you saw in the video, the first thing I need to do is to create this kind of. You can tell it's kind of a factory pattern, which is the jva streamer jpa streamer, and it needs to know what kind of persistent unit you are using because you might have several different persistent units. Now. The persistent unit is basically a container of different settings for you, your project, for example, which database I'm using what's jdbc drivers.

B

uh What's the logging credentials that I'm using at the moment, uh there are also some overloops of this function, so instead you can use the jpa factory here. Instead, I'm going to show examples of that.

B

If you use, if you like spring, you can use the watch wired annotation, so you can just auto wire this kind of instance here and you can just use it in your spring application.

B

Okay, once they have the jpa streamer instance, you can invoke this stream user class and, as we talked about before this will return, a stream of all the user rows representing all the user roles. It doesn't contain all the user roles, that's the difference because the it returns a stream representation of all users. So, as we saw before, we can add like filters and sorting and all sorts of stuff there to reduce the actual set being pulled in by the jvm.

B

So this is one example uh in this case, I'm going to actually materialize a list of strings. I I create the stream with the users of age greater than 20, and I apply this kind of mapping here using a standard stream operation. I extract the first name space and the last name, and then I can just just collect that string into a list like this.

B

Now, of course, this is the terminal operator, so the terminal operator will go up here and see wow this filter. Here I can merge that in the sql and then it will continue to this map and of course it will see that I can't merge this into the sql code, because this is a java, dynamic lambda. So that's not really possible to merge into the database query so from this point on a logic will be executed in jvm and not the database, but this line here will be optimized away and merge into the sql query.

B

So this, as I said, this user refers to the metadata model, that's been generated by the annotation processor and it's not only filtered. I can use this, it's the sort operators and also some other operators like all match and similar stuff. Actually, when you come to think of it, there are many operators, many opera operations in the stream that can take predicates or other things like this to kind of enrich the stream.

B

Okay, here is another example that suppose I want to kind of distiller all the persons all the users that are from germany and has a name named otto.

B

I can do that by combining a predicate, so I can say that I want to filter all uses by the country equal to germany and another predicate user first name equal to auto, and then I will go to the count visit, which is a terminal operation. The count will go up here and see that wow. I can recognize this predicate. It's a post predicate that com is composed of two parts.

B

This predicate here and this other predicate here, which both of them has enough metadata that will be merged into the sql so that it can recursively traverse into this kind of compositions and extract this as a sql, and it can also actually extract this terminal operation into sql, because this operation doesn't require anything in the jvm to be materialized.

B

So this can be replaced by a simple count operation. So in fact, the entire stream pipe damage just collapsed and sent to the database, and the only thing we pull in into the jvm is a long value.

B

So that's quite cool, so uh you, you can see this. You will kind of issue a command like select count from where and the result of that count will be fed into this variable here called count.

B

Okay, there is, there are some constraints. Obviously you need to use, as I mentioned predicates that are using the metadata model. Otherwise they can't be merged into the the sql query. So if you write this, this means that you, your lambda here, will be executed in the jvm, whereas in this case it will be generated and merged into a sql operation.

B

So that's the first part of the presentation in the second part, I'm going to talk about the a classical potential spring application and this spring application is going to use an example. Example database called sakila now sakila is a kind of a test database that you can use with different applications, and it's about a dvd rental store for the for your young guys, a rent, dvd rental store. You had to go there, you flipped through all the films.

B

You decided what film you want to rent you paid for it, and you went home watch the film and the next day. You have to go there and return the film again.

B

I mean we can laugh about that these days, but that was how it was, but this a subset of this database is still relevant uh and the portion describing films and actors and languages and stuff can be used as kind of a test application. So this is a standard spring application.

B

I've added a dependency for a jpa provider like hibernate, and I write my jpa entities like the one. I showed you before about users, but in this case it will be called films and actors and so forth. I also build a view model to represent a kind of a subset of I want to present.

B

With regards to a film, I don't want to present all there might be 20 or 25 different properties of a film, but I only want to show a small set of them, a small portion so that that is what my view model does.

B

So I kind of go about and create the pom file with my normal spring project. I include the standard jpa streamer dependency, which I show you in the video, and I include this this little spring extension here called the springbook jpi streamer autoconfigure, which is actually just a single class which will wrap the jpa persistence into this jpa. Streamer kind of factory thing you need to inject in your spring application.

B

um Then I added a small number of entities. I added film actor and language which are all related. Actually, they are related through some of some relations, some foreign keys, and then I created this view that exposed just a title description. Language and which actors are appearing in in a certain film. So that's the only thing I want to expose in this particular example, and here is my complete rest api.

B

So it's a rest controller, as shown here and this. The first lines here are just to inject my jpa streamer instance, the actual feature and the actual servlet or whatever it's called, and nowadays is like this entry point, I think, is s slash fields and it has two parameters. uh It says a page which page I'm going to show and a page size, defaults, 0 and 10., and this is the actual logic.

B

So I'm going to create a stream of my film entities, I skipped page times page size and I only see page size entries and then I invoke this map field view model from this is a static constructor that takes a film and turns it into a film view model and that's that and because of you can return a stream in in spring. This is actually quite nice. You don't have to materialize this to a list or something like you just return the stream and it will be rendered by the by the web server.

B

So that provides a quite neat way of integrating jpa streaming with the endpoints in spring.

B

Okay, so I know, if you invoke this, it will show the title description, language and and all the actors here that appeared in this field and actually it will show nine other things which couldn't be fit in this to this page. Here.

B

Okay, that's that, but sometimes when you write complex database uh applications, you you got problem with performance, so one of those performance problems are called the n plus one select issue so, for example, suppose that we have a uc class that has a foreign key to to a city.

B

You, you want a normalized database when you have a table representing the cities and another table representing the users, and you want to kind of use them together and you have created a jpa entity that has a one-to-one relation between those and then you want to stream over that and use both users and cities, and that is typically a a root of problem, a cause for problems, because by default, uh these kind of associations are lazy.

B

So, every time you do something with the user, it's going to create a query that is looking at which city is this, but you can avoid this with a jpa stream. You can say that, instead of just using user.class, you can use a configuration of class and saying that you I want to use a stream of users, but I also want to join in user city into that eagerly, and that provides me with a good means to control this kind of n plus one select issue.

B

B

Okay, so using hibernate in the api can easily lead to high code complexity. You have all these builders or mixing sql with java, and so therefore we integrate the jpi streamer with jpa, which allows you to compose type safe and express your database query. It uses standard java stream, so you don't have to learn a new api. It's the api, you probably already know, and you can migrate your own code to jpi streamer either you can do it now. You can do it later or you can.

B

You can forget about it and never migrate or code, because jpa streamer can coexist with your old code. It doesn't require you to do anything. Actually you can just use it in one place and then just everything run as it used to be. So I think that's a good uh property of a library. You shouldn't be forced to use it you you should be able to use it where it makes sense or what you think it makes sense.

B

So that was the first part of this talk. Now I'm going to head over to the second part, which is a actual code demo and all of the demos I'm showing here, is available for you and an open source project on github called speedman jpa streaming demo, and you can go here and reproduce everything I'm going to show you here.

B

So that's that so I'm going to head over to my development tool here and idea- let's, let's close all these, so we kind of start with the clean sheet close our tab. Okay, so here is the api streaming demo, which is exactly or almost as that gets looks like today. Some changes here, I haven't checked in yet so let's take a closer look at the pom file first, so this is a normal hibernate kind of project.

B

I depend on jpa streaming core. I depend on hibernate core. I have some other hibernate stuff here and I'm using the mysql connector here nothing surprising here at all.

B

We can also take a look at the persistence clause here. Just a second- and here you can see that we call this persistent units aquila, which is the name of the exemplary database. We are using we're using hibernate as the persistent provider by using this driver and we're using well this very secret password here. I'm running this as a docker instance, so it doesn't uh mean anything that you know the very secret password here.

B

Interestingly, I have enabled show sql here, which means that every time I run things something the sequel code will be dumped out on the console, and that's that's really nice, because now you can see what's what all the the the streams are actually being merged too. So you can actually observe. What's happened under the hood here, we can also head over here to the model, which is this entity jpa entity. Here, it's a film and it's nothing surprising at all. It's a film id which is the id.

B

We have title description, language and the usual stuff. Here we have also actors which is a management relation using a join table here and it's a list of actors. So this for each film. I can just invoke actors and see see what kind of actors participated or appeared in in this film.

B

I also had a modulation of the actors actors. It's very similar actor id first name last lame and so on, there's also a language table which tells which language this is okay. So let's look at the first simple demo: it's called simple demo number one.

B

So this is my main method. I create an instance of jpa streamer using the sakila a persistent unit. Name remember: this is the same name as this one here in the persistent unit.

B

So that's how they are connected so and the object here is to produce a list of all films that has a length between 100 and 120 minutes, and I want to use the then kind of inclusive behavior, that's standard for java and for your right standard that this, uh this parameter from start will be included, but this end will be excluded. That's the standard java behavior! I know that's different from from sql, but, as I mentioned before, I like to live in the java world, so I create this stream of films.

B

I apply this filter here and then for each film that passes this filter. I invoke this method print film. This is a static method. You show here, and you can see that it just prints out. It extracts the film id the film title, the film rating and the film length, and it just prints it out on the console like this. So I expect a number of films being printed with a link between this value here and let's run it and see if it works.

B

So around this I see hibernate starts. I see a splash screen here of a jpa streamer and which version I'm using 1.0.2 at the moment, uh also worth to mention it's that it has the same license as hibernate. So this makes it easy to integrate this in your existing project.

B

Okay, so now you can see, what's ha it's happening under the hood, so we will have a select film from film as films, where film length, equal or greater or equal than my first parameter, and the firm length is less than the second parameter, and that was exactly what I want to do this between. So I wanted everything with 100 or greater to be included and everything, that's 120 and less to be included and that's being sent to the database and only those films that matches this predicate will ever be pulled in by the jvm.

B

And here I see them using my print film methods or id number four call this one affair prejudices which is rated at g and it's 117 minutes long now, this kind of rating here this is the american I think movie association or something that rates films and to kind of prevent kids from seeing horror, films stuff, like that, I think ge.

B

Anyone can see that, but pg is parental guide in 13 years and above so this kind of puts a restriction on it and this r, that's a really horrible film that you have to be much older to to watch.

B

Okay, that's cool, but what happens now if I want to print the entire film everything that's in a film and not only this one here. So let me do that. Let me duplicate this row here and I will just dump out what's on the what's on the in that entity, so I'm using this method, reference here system out print line that will invoke the tostring on my film and print everything else.

B

I'm going to run that now, and I expect this to print more than what I saw before, but nothing else, but I'm going to be disappointed, so it runs and as you can see, it actually does print a film with a lot of more information.

B

As you can see, I can scroll on and kind of determine all the details of the actors and all that stuff, that's in in it, but for each uh film, I'm printing, there's a sql query going on behind the scene and actually two secret queries because, as I mentioned, we have a foreign key reference here. We have a manage many uh kind of relation, and this is uh inducing this n plus one select problem here.

B

So how can we come around that problem? So I'm going to revert this change.

B

um I just show you and head over to the next demo, which is called simply reward when joining, and this is how I solve the problem so instead of using only the class as a parameter, I'm using this configuration of a film class where I'm joining film actors and joining film languages before I actually send this query to the database and now I've solved the problem, because actors and and languages are going to be eagerly joined into my my film class here, and I don't have to kind of clutter down and decide that in my model film, I can decide that every time I create the stream.

B

So I can have this logic broken out to another uh another place where I, for example, apply sorting and filtering and all that stuff, and then I can just have a parameter. What I want to join in some cases it makes sense to have lazy loading and in some cases it doesn't- and I can do this all on demand here by just supplying different configurations to my stream.

B

So, let's run this and see what happens I'm running here and now I see all the films here and all the contents of the film and just one select query, and if we look a little bit more carefully into that, I see I have a film as films and then left join language has generated well. This is an internal thing and I left join actors here, so you can see that under the hood, this is interpreted as a join operation, actually two joint operations.

B

Where also I apply my my predicate here so most of the stuff, exactly everything in this joining and filtering was merged into sql operation and only the printing was actually conducted into the jvm. Of course, you have to materialize this film, using the jdbc driver. Also, that's also been taking care for you automatically.

B

Nice, so let's look into another demo. Here is a more complicated demo, where I am also looking at films and now I'm interested in all the films with the rating equals g, but I want them sorted in length order reversed. That means that I will start with the highest one and then this end have a descending order and and if they have the same length, I apply a second level of of compare, compare comparator here.

B

Then I want to order them in tight order, and I am interested in skipping the 10 first and then seeing the next five of them. So maybe I'm completing a result list or something using some kind of competition, and then I apply this print film. So I don't get all this clutter information here. I just am I'm interested in much smaller thing, so I'm going to run this here and it appears to work.

B

I have this kind of sorted in the in the right order, uh whether this is uh correct or not it's difficult to say here, but I can look at the actual sql query and I can see I have from film where film rating equals this first parameter, which was g and order by film length, descending and field length ascending, which is a secondary kind of order criteria here.

B

So that's all good and well maybe I'm now interested in something more than just g, maybe I'm interested in in a set of operation here. Maybe I would like this to be in something g and what's a pg, let's take pg-13 here, which was another rating so now I can run this and see what happens.

B

So it's very easy to kind of manipulate this scanner. Now you can see that now we have both g's and pg-13, for example here. So this shows that it's very easy to kind of use. These kind of predicate builders.

B

Here I have a bunch of operation here that I can have it's not null between contains ignore case and all that stuff, and I don't have to worry about what is the ignore case in my particular language, using a database, maybe I'm using today, I'm using my sweetgel, but maybe tomorrow I'm going to use an oracle database or something else. Then I don't have to rewrite my my sql code. It's just happens automatically.

B

I will revert this one here: okay, cool. Let me just check what the time is, so I think I have time to talk about a little bit more.

B

Let's talk about transactions so in in enterprise application transactions are very important and that that is why you can obtain a jpa streamer instance using access entity manager factory instead of just the resistance name, because uh transactions are kind of local to an entity manager factory instance- and I will go hop over the details here, but actually you use an entity manager, you, you can get a transaction and then you can use jpa streamers as any jpa operation, so it kind of fits in very nicely with the concept of transactions in jpa.

B

So you just use a stream as you would use any jpa operation here. So you can see that you're, we are updating stuff and then we're using entity manager merge here within the stream uh here. So that's that's cool! Here's another example of uh of doing a union.

B

I think this can be made in a better way, and but this is just an example how you can kind of compose a stream that creates sub streams. So this is a stream of this stream and this other stream flat mapped, and then we apply distinct because we don't want to have duplicate union. If you want duplicate um union, then you can just remove this and they will appear two times if there are exist in both of the streams above now. Obviously this can be made in a more efficient way.

B

Let me just outline how you can do this in a more efficient way. So, instead of joining two uh streams here, you can you might as well just or predicates together. So if the filament is greater than 20 or this film length is pg-13 for example, here then I want to do something here for each. Maybe I want to print them out, so I just print line them, and this is more efficient, so I'll just comment away this and instead of issuing two streams. So this is really just one one stream and one sql query.

B

So I'm going to run that now and this will create kind of a all the union of these two predicates. Actually so I'm going to oh sorry, I'm going to revert this back again and see what it was here.

B

Oh cleaning up connection pool now they fixed this bug in in the jdbc driver for my sequel, so that means I can remove this kind of quirk here, that's great, because now the examples will be easier. So now this won't be stuck as it used to be with the old mysql driver I'll, try this here yeah. It worked great okay, so, let's head over to this map custom class. So this is similar to the example we had with the with the spring example.

B

So here I have my own class, which is called title length which, unsurprisingly just had the title and length here, and it has a constructor which allows me to extract the title and length, and it has a two-string method like this. So this allows me kind of wrap something more complex into something more more simpler and if you are using java records, it will be even simpler to do this here.

B

So if I run this now map, I'm going to use this map operation to map. To my simple one- and here you can see that this is not the film issue anymore. It's my more simple title length here now. You might think that well, this sounds good, but this is actually just a projection.

B

I'm just projecting these two to something more simple. This is kind of a tuple here. So isn't there a better way to do it and of course I wouldn't say that if there wasn't a way to do it in a better way, so I'm going to head over here to the projection demo here so here I create a stream of film classes. I sort them in length reverse order. I only interested in the first three and then I do something here. I map a projection of select, so this is actually similar to select.

B

So I can select film id and film title here only so that means that, after this step here, only film id and film title kind of survives this translation. So when I run this, I expect something similar to this, but not the title length clause here, but rather something more generic.

B

So I'm going to run this and see what happens, and indeed I got something more um better. So I got this triple list, which is an id and a and and a title, an idea, another title: maybe I want to expand this, maybe I'm interested in length too. So then I can just add films and length, for example- and let's run this again with my changes and I expect the length to be there and well it's there. I wasn't let down by a jpa streamer. So now we have.

B

We have this length here too again, I'm going to revert this okay. So that's that now I'm going to show two more kind of more complicated streams.

B

The first one is about partitioning now partitioning is that you have two buckets and you want something to end up in one bucket and something else ending up in another bucket, and this is something that streams support from from the beginning out after the box, so to speak.

B

uh So, let's see where, where that is partition them it's here, so um I'm just going to stream over the film entities here and then I'm going to collect them partition by- and this is a partition key here- it's not a key, but it's a predicate that will either be true or false and depending if it's true or false, it would end up in either the two or the false button in this map here. So there's a map of two actually keys or at most two keys, and then it's a list of of films here.

B

So when I run this, I expect that about half of the films will be greater than than two hours, and hopefully it's like less. Maybe it's slightly less slightly more films will be less than two hours because I think two hours is quite a long film.

B

So I'm running this and you can see how nicely it interacts with the kind of stream ecosystem here. This is completely unknown to jpa. The stila can use all the the collectors and everything that's in in the stream library.

B

So apparently there were uh 543 films which were longer than two hours and slightly less under so maybe there were kind of a tendency to include longer frames in this particular database.

B

Finally, I'm going to look at the really advanced example of using java.

A

Per we've got a question from the audience if it would be possible to zoom in on the code a little bit as it is a little tough to read at this size.

B

ah I see I'll try to do that.

B

um Well, it changed this so.

B

uh Not sure, if that, if there is presentation mode, maybe have you, I think there used to be a presentation mode, can't find it though appearance, tool.

B

Well, it has moved I'm sorry for that. I know there's another way of setting the the font size here, not sure how that works, but maybe it's like preferences.

B

Let me try and uh editor font I'm getting there and let me type 18.

B

wow huge improvement thanks for that um feedback, so I hope you can see this better.

B

Okay, so that's that so, let's head over to the pivot demo, now the pivot demo- that might seems a bit frightening here. But what we actually want to do is to create something that, for each actor, creates a map of the different, um the different ratings uh number of film.

B

That actor participated in, for example, there might be an actor that is more likely to do horror, movies and then that actor is has more appearances in r files, whereas there are kind of child stars and they're much likely to appear in films that are rated by g, which is available to the general audience.

B

So that's what I want to do and, as you can see, I'm using java 8 notation here, but if I would have used something else, I can just like var notated this. uh Fortunately, unfortunately, I don't have that available at the moment, but that makes things a bit more simple here. So I'm going to create a stream over my actor class and I'm going to eagerly join in films, because I only want to do one query and then I collect them grouping by which is a standard collector.

B

In java and I'm grouping them by something called.

B

What is called a cat? Oh, it's called something: uh let's see what it's called uh well, I've got the name anyway, it's a cla as a classifier. Sorry for that, so it's called the classifier and the classifier it's. It is the actor itself. I might have selected to extract the name object for example, but I want the entire object to be here as the classifier and then I stream over all the films uh flat mapping, all the films and I'm grouping them again by rating, but I don't want all the ratings.

B

I just want to count them so that that's what I'm expressing here using this, uh perhaps some of you aren't that use used to use java streams, and this might sound a bit frightening, but actually it's a very powerful way of composing your your layers. So this is actually a second order of of uh grouping by here and you can have any order and any depth of this.

B

So if I run this now here.

B

This is also bigger, so now you can see that, for example, this kirk jonovich appeared in four films with pg-13 two r films and eight of these and so forth. So this shows a very neat way of interacting with the stream ecosystem, with the jpa using jpa streamer.

B

So that was about hibernate that let me just uh touch a little bit on on the spring demo that I showed before so again. We have this model of film actors and languages. I will not go into the details of that. I had this film view model, which is similar to my custom class that I had before so this.

B

This extracts the id title description, language and a list of actors from a film, and here is this kind of static constructor that takes the field and returns a new freedom view model, I think, actually, in the real case, it might be the case that this object is never created. It might be detected by the escape analysis of of the jvm and c2 compiler. So in some cases this will never be actually created on the heap depending on on a number of uh issues here, and this again is the controller.

B

So this is very similar to what I presented and, on my slide, so I will ought to inject this jpa streamer via this autowide constructor here and then I will invoke this kind of endpoint here, using page and page size and I'll just return. The stream here using my view model and that pretty much completes my intended presentation and, of course, if you have more questions other than and the font size, I'm very happy to to answer them.

B

And why don't you try jpa stream and head over to jpstream.org and kick the tires, and let me know what's good and what's bad, because I want to know that too, what can be improved and how does this fit your needs and if you need help or or consulting, we are here to to help so that that's it and thank you for listening in today, guys.

A

Awesome well, thank you very much prayer for that excellent presentation. At this point, I'm not seeing any questions in the chat, but what I will do is I'll. Just do some quick housekeeping items before you wrap up here and if anybody has questions we can get to them after that. um So the next jakarta tech talk takes place on may 18th and we have ryan super act, presenting yg card ee matters, and I just posted the link in the chat for that.

A

If you would like to register by all means, another follow-up, jakarta e is still collecting submissions for the 2021 jakarta e-developer survey.

A

Completing this survey helps provide input for the java ecosystem stakeholders to better understand requirements, priorities and perceptions of the enterprise developer communities, and if you would not take a minute or not mind taking a minute to fill that out, if you haven't already, I just posted a link in the chat for that as well.

A

Third, we are always looking for more tech talks. If you would like to present um something to do with cloud native java or a project you're working on in the community, you can sign up to present it here and finally, if you have any feedback, we are always looking for to see how we can improve the tech talk program.

A

So that would be great if you could do that as well. At this point, I am not seeing any more questions, um so, if again, if anybody has any more, please feel free to ask, but thank you again per for taking the time to join us today.

B

Thanks for having me perfect, so thanks a lot.

A

All right, everybody enjoy the rest of your day.

B