+ Although I don't generally write much, sometimes I'll find something interesting, or something that I notice a significant number of people could benefit from reading about. In that case, it'll most likely end up on this page as an article. +
++ Written on , by Andrew Lalis. +
++ Nowadays, if you want to build the next fancy new web app, chances are pretty good that you'll need a search bar in it, and for that, you've probably heard of ElasticSearch, or some other fancy, all-in-one solution. However, in this article, I'd like to try and convince you that you don't need any of that, and instead, you can brew up your own homemade search feature using Apache Lucene. +
++ Hopefully you'll be surprised by how easy it is. +
++ Before we dive into the code, it's important to make sure that you actually need an indexing and searching tool that goes beyond simple SQL queries. +
++ If you can answer "yes" to any of these questions, then continue right along: +
+tig*.+ No matter what searching solution you end up choosing, they all generally follow the same approach: +
++ In most situations, ingesting data roughly translates to scraping content from a database or message queue, or even CSV content. The contents of each entity are analyzed and the important bits are extracted and stored in a compressed format that's optimized for high-speed searching. The exact implementation depends on what sort of solution you choose, but a lot of databases use a sort of red-black tree structure. +
++ Searching over your index involves parsing a user's query (and sanitizing it, if necessary), and then constructing a well-formed query that's accepted by your searching solution, possibly with different weights or criteria applied to different fields. +
++ This is no different for Lucene, and in this guide, we'll go through how to create an index and search through it. +
++ In this guide, I'll be creating a small Java program for searching over a huge set of airports which is available for free here: https://ourairports.com/data/. The full source code for this project is available on GitHub, if you'd like to take a look. +
++ I'll be using Maven as the build tool of choice, but feel free to use whatever you'd like. +
++ We start by creating a new project, and add the apache-lucene dependency, and the Apache Commons CSV library for parsing the CSV dataset. +
+
+ <dependencies>
+ <!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-core -->
+ <dependency>
+ <groupId>org.apache.lucene</groupId>
+ <artifactId>lucene-core</artifactId>
+ <version>9.5.0</version>
+ </dependency>
+ <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-csv -->
+ <dependency>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-csv</artifactId>
+ <version>1.10.0</version>
+ </dependency>
+ </dependencies>
+
+ First of all, we need to parse the CSV data into a programming construct that we can use elsewhere in our code. In this case, I've defined the Airport record like so:
+
+ public record Airport(
+ long id,
+ String ident,
+ String type,
+ String name,
+ double latitude,
+ double longitude,
+ Optional<Integer> elevationFt,
+ String continent,
+ String isoCountry,
+ String isoRegion,
+ String municipality,
+ boolean scheduledService,
+ Optional<String> gpsCode,
+ Optional<String> iataCode,
+ Optional<String> localCode,
+ Optional<String> homeLink,
+ Optional<String> wikipediaLink,
+ Optional<String> keywords
+ ) {}
+
+ And a simple AirportParser class that just reads in a CSV file and returns a List<Airport> (Check the source code to see how I did that).
+
+ Now that we've got our list of entities, we can build an index from them. +
++ In order to efficiently search over a massive set of data, we need to prepare a special set of index files that Lucene can read during searches. To do that, we need to create a new directory for the index to live in, construct a new IndexWriter, and create a Document for each airport we're indexing. +
+
+ public static void buildIndex(List<Airport> airports) throws IOException {
+ Path indexDir = Path.of("airports-index");
+ // We use a try-with-resources block to prepare the components needed for writing the index.
+ try (
+ Analyzer analyzer = new StandardAnalyzer();
+ Directory luceneDir = FSDirectory.open(indexDir)
+ ) {
+ IndexWriterConfig config = new IndexWriterConfig(analyzer);
+ config.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
+ IndexWriter indexWriter = new IndexWriter(luceneDir, config);
+ for (var airport : airports) {
+ // Create a new document for each airport.
+ Document doc = new Document();
+ doc.add(new StoredField("id", airport.id()));
+ doc.add(new TextField("ident", airport.ident(), Field.Store.YES));
+ doc.add(new TextField("type", airport.type(), Field.Store.YES));
+ doc.add(new TextField("name", airport.name(), Field.Store.YES));
+ doc.add(new TextField("continent", airport.continent(), Field.Store.YES));
+ doc.add(new TextField("isoCountry", airport.isoCountry(), Field.Store.YES));
+ doc.add(new TextField("municipality", airport.municipality(), Field.Store.YES));
+ doc.add(new IntPoint("elevationFt", airport.elevationFt().orElse(0)));
+ doc.add(new StoredField("elevationFt", airport.elevationFt().orElse(0)));
+ if (airport.wikipediaLink().isPresent()) {
+ doc.add(new StoredField("wikipediaLink", airport.wikipediaLink().get()));
+ }
+ // And add it to the writer.
+ indexWriter.addDocument(doc);
+ }
+ indexWriter.close();
+ }
+ }
+ Optional, so we need to be a little careful to not end up with unexpected null values in our documents.
+ An important takeaway here is the construction of the Document. There are a variety of fields that you could add to your document, which have different effects on the search.
+
+ For more information about the types of fields that you can use, check the Lucene documentation. It's very well-written. +
++ Also important to note is that once a document is added, it's staying in the index until either the index is removed or overwritten, or the document is deleted through another IndexWriter method. I'd suggest reading the documentation if you'd like to learn more about how to dynamically update a living index that grows with your data. But for 95% of use cases, regenerating the search index occasionally is just fine. +
++ Now that we've built an index from our dataset, we can search over it to find the most relevant results for a user's query. +
++ The following code might look a bit daunting, but I've added some comments to explain what's going on, and I'll walk you through the process below. +
+
+ public static List<String> searchAirports(String rawQuery) {
+ Path indexDir = Path.of("airports-index");
+ // If the query is empty or there's no index, quit right away.
+ if (rawQuery == null || rawQuery.isBlank() || Files.notExists(indexDir)) return new ArrayList<>();
+
+ // Prepare a weight for each of the fields we want to search on.
+ Map<String, Float> fieldWeights = Map.of(
+ "name", 3f,
+ "municipality", 2f,
+ "ident", 2f,
+ "type", 1f,
+ "continent", 0.25f
+ );
+
+ // Build a boolean query made up of "boosted" wildcard term queries, that'll match any term.
+ BooleanQuery.Builder queryBuilder = new BooleanQuery.Builder();
+ String[] terms = rawQuery.toLowerCase().split("\\s+");
+ for (String term : terms) {
+ // Make the term into a wildcard term, where we match any field value starting with the given text.
+ // For example, "airp*" will match "airport" and "airplane", but not "airshow".
+ // This is usually the natural way in which people like to search.
+ String wildcardTerm = term + "*";
+ for (var entry : fieldWeights.entrySet()) {
+ String fieldName = entry.getKey();
+ float weight = entry.getValue();
+ Query baseQuery = new WildcardQuery(new Term(fieldName, wildcardTerm));
+ queryBuilder.add(new BoostQuery(baseQuery, weight), BooleanClause.Occur.SHOULD);
+ }
+ }
+ Query query = queryBuilder.build();
+
+ // Use the query we built to fetch up to 10 results.
+ try (var reader = DirectoryReader.open(FSDirectory.open(indexDir))) {
+ IndexSearcher searcher = new IndexSearcher(reader);
+ List<String> results = new ArrayList<>(10);
+ TopDocs topDocs = searcher.search(query, 10, Sort.RELEVANCE, false);
+ for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
+ Document doc = searcher.storedFields().document(scoreDoc.doc);
+ results.add(doc.get("name"));
+ }
+ return results;
+ } catch (IOException e) {
+ System.err.println("Failed to search index.");
+ e.printStackTrace();
+ return new ArrayList<>();
+ }
+ }
+ Query object is passed to an index searcher to do the searching. But first, we need to build such a query. In our case, we want to match each term the user enters against any of the fields we've added a weight for. By using a BooleanQuery, we can construct this as a big OR clause, where each term is a wildcard query that's boosted by the weight of the field it applies to.TopDocs object that has a scoreDocs property containing the list of document ids that appear in the results. We can use the searcher to lookup the stored fields of each document in the result set, and in this case, we just fetch the name of the airport.+ That's it! In my sample project, the whole Lucene implementation for indexing and searching, including imports and comments, is less than 150 lines of pure Java! It's so simple that it can just be tucked away into a single class. +
++ Now, with your newfound knowledge, go forth and build advanced search features into your apps, and be content that you've built your solution from the ground up, without reinventing the wheel or getting roped into a complex cloud solution. +
++ Once again, my sample code is available on GitHub here. +
++ Written on , by Andrew Lalis. +
++ Because it was designed many years after the advent of most of the main programming languages that form the + backbone of our software (C, C++, Java, Python, etc.), D has the benefit of 20/20 hindsight that it uses to + improve over some quite glaring flaws in earlier languages. +
++ From our past, we've learned a few key things which contribute to great languages: +
++ Of the other languages I've mentioned, each of those easily achieves a few of these requirements: C++ + is expressive and allows efficient abstraction, and it's very fast. However, it's generally accepted that + the learning C++ is quite difficult. Again, Python can arguably meet the first three requirements, but fails + to provide satisfactory performance for many applications. +
++ I think that D is a language which addresses all of these requirements in a modest, satisfactory approach. +
+
+ import std.stdio, std.array, std.algorithm;
+ void main() {
+ stdin
+ .byLineCopy
+ .array
+ .sort!((a, b) => a > b) // descending order
+ .each!writeln;
+ }
+ stdin in alphabetical order and prints them.
+ import java.io.BufferedReader;
+ import java.io.IOException;
+ import java.io.InputStreamReader;
+ class Main {
+ public static void main(String[] args) throws IOException {
+ try (var in = new BufferedReader(new InputStreamReader(System.in))) {
+ in
+ .lines()
+ .sorted(String::compareTo)
+ .forEachOrdered(System.out::println);
+ }
+ }
+ }
+ + Of course, I could list all of the language features here which allow D to excel in each of the basic + requirements, but in short, it offers all of the power of a low-level systems language like C++, while at + the same time offering the convenience of high-level languages like automatic memory management, and + metaprogramming. So, I think that D is somewhat unique in that it gives programmers a freedom to choose + their own preferred style; it's a language accomplishes as much as a family of languages. +
++ You'd think that all these benefits, developers would be flocking in droves to D. But clearly in the real + world, that's not the case. Why? This section outlines some of the reasons why the language + hasn't attained the same level of popularity as others. +
++ Despite their modern-day popularity, all of the major programming languages are several decades old: Java + was created in 1995, Python in 1991, C++ in 1985, and so on. D was first conceived in 2001, giving all of + these other languages years to build a loyal following. Additionally, the early version of D + was highly volatile and suffered from having two competing implementations of a standard library. In 2007, + D2 was released for the first time, marking the "stabilization" of D, and the language has essentially grown + from there. So we're dealing with a relatively immature language as of yet, which still needs to prove its + worthiness in various disciplines before it gains popularity. +
++ One fatal issue which affects many software projects is this: the project receives little attention from new + users, so it is not promoted to new users. Therefore, the project yet again receives little attention from + its limited userbase, and so on... D is no exception. Other popular languages were quickly adopted by large + corporations: Java by Oracle, C++ by Microsoft, Python by Google, etc. Now we're in a situation where most + large employers will choose a "tried and true" programming language that's been used by other corporations, + and thus less popular languages stay in the shadows. Since D isn't so radically different than other + languages but instead offers smaller meaningful, incremental improvements, it's also not the most flashy + new language for individual developers to rave about in the free time. +
++ Stemming from the other reasons mentioned above, because D is relatively new, its software ecosystem is + still growing, and lacks some of the mature, standard libraries we've come to expect from a general-purpose + programming language: a standard async library, an HTTP client, a standard GUI framework, and the list goes + on. Over time, these problems are usually solved by the community, so I believe that D will emerge with a + robust library of modules that rivals the Java and C++ ecosystems. +
++ Written on , by Andrew Lalis. +
++ You're probably used to writing your automation scripts in a language like Bash, Powershell, Ruby, or Python. With DSH, it can be just as easy to write those scripts in D. I've designed DSH as a combination of a standalone programming library, and a set of tools to facilitate faster development and deployment. This article will discuss some of the basic use cases and how DSH works to make it easier to accomplish them. +
++ In case you're interested, you can check out DSH on code.dlang.org or on GitHub. +
++ While many people are used to scripting in languages that have been built over the years specifically for that use case, this introduces extra complexity into projects that are mainly built using some other language. In an ideal world, we'd use one single language to describe everything about our app, from the way it looks, to how we compile and distribute it. DSH is my attempt to make this a reality, at least for applications written in D. When developing D programs that require some auxiliary scripts, you don't have to make a cognitive jump to another language; just keep writing code in the environment you're most efficient in. This way, we reap the benefits of specializing in becoming an expert in a single language and its ecosystem. +
++ If you're still not fully convinced, that's alright; read ahead and see if any of my examples can sway your opinion. +
++ There are two main ways to write scripts using DSH: +
+dub.sdl package descriptor to the top of your file, and an executable shebang. For example:
+
+ #!/usr/bin/env dub
+ /+ dub.sdl:
+ dependency "dsh" version="~>1.6.1"
+ +/
+ import dsh;
+
+ void main() {
+ print("Hello world!");
+ }
+ ./my_script.d
+ dshs.d version of DSH, for compiled scripts which don't use the dub package manager:
+
+ import dsh;
+
+ void main() {
+ print("Hello world!");
+ }
+ dmd my_script.d /usr/include/dshs.d && ./my_script
+ + Generally, the dynamic form is more useful for scripts you'd like to distribute to anyone, since they only require the user to have the D toolchain installed in order to run it. However, it is slower, since the script and all its dependencies must be compiled on-the-fly. +
++ Alternatively, the static form is more useful for complex scripts that are best pre-compiled, or for when you don't want to use the dub package manager, just a D compiler. +
+
+ Luckily for either of these solutions, DSH comes with a dshutil tool to help you get started. You can install it like so:
+
+ wget https://raw.githubusercontent.com/andrewlalis/dsh/main/tools/dshutil.d -O dshutil.d
+ chmod +x dshutil.d
+ ./dshutil.d install
+ + While dshutil is a handy tool on its own, the real benefit of using DSH is its library of helper functions which are designed specifically for scripting tasks. +
+ ++ DSH offers quite a few helpful functions that reduce the verbosity of your IO operations. Below is a sampling of some of the most prominent functions. +
+
+ import dsh;
+
+ void main() {
+ copyDir("fromdir", "todir");
+ string filename = findFile("dir", "config\\.json");
+ string[] files = findFiles("dir", "^config.*$");
+ string[] dFiles = findFilesByExtension("dir", ".d");
+ string home = getHomeDir();
+ removeAnyIfExists(dFiles);
+ }
+
+ In addition to the functions in D's std.process module, DSH provides some shortcuts for scripts to make it easy to manage processes.
+
+ import dsh;
+
+ void main() {
+ run("cat out.txt");
+ runOrQuit("git pull"); // exits the program if the process fails.
+ setEnv("MY_VAR", "TRUE");
+ print(getEnv("MY_VAR"));
+ }
+
+ Also included is a ProcessBuilder class with which you can use a fluent method interface to construct processes with custom input and output sources and environments.
+
+ Written on , by Andrew Lalis. +
+
+ Often times, new programmers will immediately jump into making graphical applications using their new-found skills, without getting a firm grasp of how to design something that doesn't require refactoring literally any time new functionality is required. Obviously, we can't just collectively tell all new programmers to just be patient; that will never work. So hopefully this article can serve as a guide to put you on the right track to developing 2D applications (games, most likely) using Java and Swing.
+
+ I will be referencing snippets of code that come from this repository, so check there if you want to read through all the code yourself.
+
+ Since this is quite a large guide, you can skip to a particular section if you want: +
+ ++ At first, it's super easy to make a new JFrame and start drawing on it, and you can add action listeners everywhere, whenever they're needed. If you ever plan on expanding beyond a simple 20-line drawing method however, you should organize your code using the Model-View-Controller pattern. For example, in my Before Asteroids sample game, I have split up my code into a few different packages. +
++ In most cases, it's especially useful to define a single class that represents your entire game's state; a so-called Game Model. This model would contain all the entities in your game that exist in the world, for example. Or in the case of something like a simple tic-tac-toe game, it would contain data about the status of each of the nine squares on the board. +
++ Keep this design pattern in mind, and working on your project as it grows larger hopefully won't become as much of a headache anymore. +
++ Making a Swing GUI usually consists of two basic components: the JFrame that acts as your application's window, and a JPanel that is used for actually drawing your model. Usually we start by defining our own frame to extend from the base JFrame, and set its properties in a constructor. +
+
+ public class GameFrame extends JFrame {
+ public GameFrame(GameModel model) {
+ this.setTitle("My Game");
+ this.setPreferredSize(new Dimension(800, 600));
+ // Set the frame to be disposed when the top-right 'X' is clicked.
+ this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+ GamePanel gamePanel = new GamePanel(model);
+ this.setContentPane(gamePanel);
+ this.pack();
+ // Start with the frame centered in the screen.
+ this.setLocationRelativeTo(null);
+ // TODO: Setup listeners and game loop logic.
+ }
+ }
+ GamePanel, which will ultimately be drawing the model.
+ Inside the frame, there's a single GamePanel that we give a reference to the game model. This panel is responsible for rendering the model to the screen, and usually we can just define it as a child class of Swing's JPanel.
+
+ public class GamePanel extends JPanel {
+ private GameModel model;
+
+ public GamePanel(GameModel model) {
+ this.model = model;
+ }
+
+ @Override
+ protected void paintComponent(Graphics g) {
+ super.paintComponent(g);
+ Graphics2D g2 = (Graphics2D) g;
+ g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+ g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
+ g2.setColor(Color.BLACK);
+ g2.fillRect(0, 0, this.getWidth(), this.getHeight());
+ // TODO: Draw model on screen.
+ }
+ }
+ paintComponent. The Javadoc advise calling the super method to avoid graphical bugs, so we do that first. Then we set some rendering hints to turn on anti-aliasing and how strokes (outlines) are rendered. Finally we clear the screen to a black rectangle.+ First of all, this guide won't go too in-depth about the details of game loops in general, but focuses specifically on their implementation with Java/Swing. For more information, you can read this excellent article on the subject. +
++ In Swing GUIs, your application is by-default multi-threaded, since Swing has its own thread for managing the user interface. In order to run our game and not interfere with Swing's own GUI processing, we should have our game update logic run in its own thread. The thread should periodically update the model, according to some defined frequency, and it should also trigger the rendering of frames of your game, once again according to some defined frequency. In the example below, we update physics 60 times per second, and render the model also 60 times per second, but these values can easily be changed due to how I've set up the math. +
+
+ public class GameUpdater extends Thread {
+ public static final double PHYSICS_FPS = 60.0;
+ public static final double MILLISECONDS_PER_PHYSICS_TICK = 1000.0 / PHYSICS_FPS;
+ public static final double PHYSICS_SPEED = 1.0;
+
+ public static final double DISPLAY_FPS = 60.0;
+ public static final double MILLISECONDS_PER_DISPLAY_FRAME = 1000.0 / DISPLAY_FPS;
+
+ private final GameModel model;
+ private final GamePanel gamePanel;
+ private volatile boolean running = true;
+
+ public GameUpdater(GameModel model, GamePanel gamePanel) {
+ this.model = model;
+ this.gamePanel = gamePanel;
+ }
+
+ public void setRunning(boolean running) {
+ this.running = running;
+ }
+
+ @Override
+ public void run() {
+ long lastPhysicsUpdate = System.currentTimeMillis();
+ long lastDisplayUpdate = System.currentTimeMillis();
+ while (this.running) {
+ long currentTime = System.currentTimeMillis();
+ long timeSinceLastPhysicsUpdate = currentTime - lastPhysicsUpdate;
+ long timeSinceLastDisplayUpdate = currentTime - lastDisplayUpdate;
+ if (timeSinceLastPhysicsUpdate >= MILLISECONDS_PER_PHYSICS_TICK) {
+ double elapsedSeconds = timeSinceLastPhysicsUpdate / 1000.0;
+ this.updateModelPhysics(elapsedSeconds * PHYSICS_SPEED);
+ lastPhysicsUpdate = currentTime;
+ timeSinceLastPhysicsUpdate = 0L;
+ }
+ if (timeSinceLastDisplayUpdate >= MILLISECONDS_PER_DISPLAY_FRAME) {
+ this.gamePanel.repaint();
+ lastDisplayUpdate = currentTime;
+ timeSinceLastDisplayUpdate = 0L;
+ }
+ long timeUntilNextPhysicsUpdate = (long) (MILLISECONDS_PER_PHYSICS_TICK - timeSinceLastPhysicsUpdate);
+ long timeUntilNextDisplayUpdate = (long) (MILLISECONDS_PER_DISPLAY_FRAME - timeSinceLastDisplayUpdate);
+
+ // Sleep to reduce CPU usage.
+ try {
+ Thread.sleep(Math.min(timeUntilNextPhysicsUpdate, timeUntilNextDisplayUpdate));
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ // Other methods omitted for brevity.
+ }
+ running flag to false. During the loop, we determine how long it's been since the last physics and display updates, and if enough time has passed, we do an update and reset the "timeSince..." variable. To avoid wasting CPU usage on rapidly looping, we sleep until the next update.+ We can add our game updater thread to the end of our frame's constructor, so that when we initialize the game frame, the game loop begins. +
+
+ public class GameFrame extends JFrame {
+ public GameFrame(GameModel model) {
+ this.setTitle("My Game");
+ this.setPreferredSize(new Dimension(800, 600));
+ // Set the frame to be disposed when the top-right 'X' is clicked.
+ this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+ GamePanel gamePanel = new GamePanel(model);
+ this.setContentPane(gamePanel);
+ this.pack();
+ // Start with the frame centered in the screen.
+ this.setLocationRelativeTo(null);
+
+ this.updater = new GameUpdater(model, gamePanel);
+ this.updater.start();
+ this.addWindowListener(new WindowAdapter() {
+ @Override
+ public void windowClosing(WindowEvent e) {
+ updater.setRunning(false);
+ }
+ });
+ // TODO: Setup listeners
+ }
+ }
+
+ Most often, you'll want something to happen when the player presses a key or clicks the mouse. To do this, you should create your own class which extends from KeyAdapter or MouseAdapter, depending on what you want to do.
+
+ You can also directly implement KeyListener and MouseListener at the same time, but this isn't as clean, and you have to implement every method declared in the interfaces, even if you aren't using them.
+
+ Let's take a look at a common case: doing something when a key is pressed. To do so, we override the KeyAdapter's keyPressed method like so:
+
+ @Override
+ public void keyPressed(KeyEvent e) {
+ int c = e.getKeyCode();
+ if (c == KeyEvent.VK_W) {
+ player.getShip().forwardThrusterEnabled = true;
+ } else if (c == KeyEvent.VK_A) {
+ player.getShip().turningLeft = true;
+ } else if (c == KeyEvent.VK_D) {
+ player.getShip().turningRight = true;
+ }
+ }
+ getKeyCode() on the key event that was received, and then check if it matches one of the constants defined in the KeyEvent class, and if so, then we do something to our player. In this case, we set some boolean flags that indicate how the player's ship is trying to move.+ Handling mouse events works almost the same way, but instead we check what button of the mouse was pressed. +
+
+ @Override
+ public void mouseClicked(MouseEvent e) {
+ int b = e.getButton();
+ if (b == MouseEvent.BUTTON1) {
+ System.out.printf("Player clicked at x=%d, y=%d\n", e.getX(), e.getY());
+ player.getShip().firingBlaster = true;
+ }
+ }
+ getX() and getY() return the x- and y-coordinates relative to the source component, which will most often be the JFrame or JPanel that the user clicked on.+ Written on , by Andrew Lalis. +
+
+ If you're reading this article, there's a good chance you've already heard about Spring's controversial OpenSessionInViewFilter, which allows lazy loading of entity relations during the rendering of a web view. In case you haven't, I suggest reading this excellent article by Vlad Mihalcea which goes into much more detail on why one should avoid using the filter entirely.
+
+ This article will focus on the practical way to structure your application logic so that you can still take advantage of Hibernate's lazy loading, without using the OSIV anti-pattern. +
++ At first, many of the simple tutorials you'll read online will have you passing your entity models to Thymeleaf or JSP templates to render a web page for your application. This convenience is what leads developers to use OSIV in the first place, because they start fetching attributes of their entity which were not initially loaded. This is fine for the most simple "Hello World" starter projects, but as soon as you add any real complexity, this "convenience" breaks down into an unorganized mess, where it is not clear at a glance where data will be fetched from the database. +
++ One solution, which beginners often turn to, is to simply eager-fetch all the attributes they'll need using a their data-access object (usually a repository with a custom JPQL query). This works well enough, and is often the preferred solution since it's about as optimized as you can get. The issue with this approach is that it's just not scalable to maintain a huge library of queries that are each tailor-made for a particular use case, and tends to sidestep Hibernate's powerful lazy-fetching features. +
+
+ @Query("SELECT a FROM Assignment a " +
+ "LEFT JOIN FETCH a.gradings " +
+ "LEFT JOIN FETCH a.zippedFile " +
+ "WHERE a.id = :id")
+ Optional<Assignment> findByIdWithAllRelations(Long id);
+ Assignment entity is used in 150 different places in our code, each with different requirements for which attribute need to be fetched, then this becomes unsustainable.+ Eager-fetching the right attributes for an entity still leaves you with the issue of passing your actual entity object to the view for rendering, which means that an unsuspecting developer will eventually try to read a lazy-loaded attribute, which will throw a LazyInitializationException. The solution to that issue, is to not pass your entity to the view at all, but instead pass a data-transfer object (DTO) containing exactly the data that the view requires, and nothing more. And now, your service layer is responsible for producing this DTO, and it can take full advantage of Hibernate's lazy-loading functionality. +
+
+ The Spring framework allows you to annotate a service's method as @Transactional, which means that at runtime, when your method is called, a proxy method is wrapped around it which starts a transaction (and thus a Hibernate session to go with it) that persists for the duration of the method. Inside this method, you are free to fetch lazy-loaded attributes from an entity, without having to deal with LazyInitializationExceptions.
+
+ @Transactional
+ public boolean isPersonAdmin(long personId) {
+ Person p = this.personRepo.findById(personId).orElseThrow();
+ for (Role r : p.getRoles()) {
+ if (r.getName().equals("ADMIN")) return true;
+ }
+ return false;
+ }
+ isPersonAdmin, which looks to see if a person has the "ADMIN" role. This will work even if the person's list of roles is lazy-loaded, because it all happens in the context of the transaction.+ One caveat to be aware of is the fact that entity object should not be passed as arguments to a transactional method, since the Hibernate session that is dedicated to the transaction has no idea what that entity is, and thus can't fetch lazy attributes from it. +
++ However, the flexibility of being able to use lazy-loaded attributes the easy way more than makes up for the strict encapsulation rules, and by structuring your project around service methods as black-box operations, you'll be able to build huge projects while keeping your sanity mostly intact. +
++ Written on , by Andrew Lalis. +
++ Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi dignissim feugiat tortor. Donec non gravida massa. Interdum et malesuada fames ac ante ipsum primis in faucibus. Aliquam eleifend nunc placerat ante suscipit consequat. Nulla tempor pellentesque mollis. Nam malesuada risus urna, ac fermentum dui egestas sit amet. Ut vel tellus eros. Phasellus massa erat, dignissim ac arcu non, vestibulum rhoncus diam. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec pharetra pretium purus, et tempus elit tristique maximus. Donec imperdiet, enim et consequat pharetra, purus augue congue nulla, a hendrerit nulla est id augue. Aliquam erat volutpat. Fusce eu lorem purus. +
++ Curabitur lobortis convallis nunc interdum mattis. Suspendisse tincidunt nec mi in elementum. Vestibulum eu sagittis felis, at bibendum odio. Quisque tortor mi, convallis ut nulla id, scelerisque scelerisque eros. Duis convallis enim lorem, sit amet congue ipsum eleifend et. Phasellus finibus elit nibh, nec sodales nisi vehicula quis. Quisque a elit nec turpis maximus posuere id ac turpis. Aliquam efficitur accumsan tortor, sit amet hendrerit eros faucibus eget. Mauris non est in lectus hendrerit varius pellentesque at ante. Morbi sit amet suscipit ligula, vitae condimentum quam. Etiam diam nunc, vehicula a fermentum nec, varius nec diam. Etiam elit tellus, mattis eu libero quis, faucibus varius est. Here is a link to Google.com. +
+
+ /**
+ * Shortcut for getting a property.
+ * @param key The property's key.
+ * @return The value for that property.
+ */
+ public static String getProp(String key) {
+ return getInstance().getProperties().getProperty(key);
+ }
+ + Praesent elementum quam in odio sodales, vel suscipit massa dignissim. Aenean id molestie lectus. Vestibulum eu magna scelerisque dui elementum molestie. Vestibulum vitae interdum felis. In rutrum turpis at posuere fermentum. Interdum et malesuada fames ac ante ipsum primis in faucibus. Duis porta blandit blandit. Morbi ut vehicula metus, tristique ultrices justo. Vivamus ullamcorper convallis tempus. In et laoreet quam. Maecenas lobortis, enim ut tincidunt ultricies, dui mauris dictum magna, vel facilisis nunc nisi at ligula. +
++ Some small text. +
+
+ void main(int argc, char** argv) {
+ printf("Hello world!\n");
+ }
+