DEV Community: Carter

Java JDBC + IntelliJ + SQLite - A Beginner's Walkthrough

Carter — Tue, 17 Dec 2024 05:43:31 +0000

IntelliJ Community + JDBC + SQLITE

(or any other database)

no build tool required (Maven or Gradle)
we'll be downloading the sqlite command-line shell (https://www.sqlite.org/cli.html)
- this will make it easy to create a database file and use it as our connection in jdbc.
sqlite drivers from (org.xerial.sqlite)

Step 1: Project Setup

1.1 create a new project

File > New > Project..

click on New Project
pick a name for your project (we will be calling it jdbc-test)
click Create

1.2 adding the sqlite driver

once your new project is created go to

File > Project Structure > Libraries

click the + sign and then Maven
(you could also download the jar yourself
sqlite driver jar,
Maven just does it for you)

search for org.xerial.sqlite-driver and use the latest version (3.42.0.0 as of this commit)
optional: you can choose to store your library in a lib folder for organizational purposes.
click okay to add the dependency.

Step 2: Getting a Database File with the SQLite

2.1 downloading the tool

visit the sqlite downloads page
install the precompiled binaries for your target OS

make sure your download has the following description:

A bundle of command-line tools for managing SQLite database files,
including the command-line shell program, the sqldiff.exe program,
and the sqlite3_analyzer.exe program.

2.1 identifying your tools

unzip the downloaded folder and view the contents inside.
you should see sqldiff, sqlite3, and sqlite3_analyzer.
you are only interested in sqlite3 for now.
start sqlite3

2.3 using sqlite3 cli

to create a new database file simply type

.save [name-of-database-file]

this will create a new file in the same folder as the sqlite3 application.

2.4 handling the database resource file

move the file into your IntelliJ Community Edition project.
you can store in the root directory or in some resource folder

Step 3: Using JDBC and SQLite

you are now ready to start using Sqlite and JDBC!

you can learn how to use JDBC through the following resources:
- https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html
- https://www.baeldung.com/java-jdbc

look through the source code for a quick example using our newly created database file.

Functional Programming in Kotlin pt. 1

Carter — Fri, 08 Nov 2024 15:43:52 +0000

In Kotlin you can write pure functions and harness the power of functional programming in a similar fashion to Scala.

Side-Effects are state changes that persist out side of the local return value of a function. Mutator methods of a class are an example of functions that create side-effects, these kinds of functions are called procedures.

Referential Transparency is the idea in functional programming where replacing a function call with it's returned result will not change how the program behaves.

Pure Functions are referentially transparent because they do not create any side-effects.

The benefit of referential transparency in pure functions show up quiet apparently: The program becomes no less complex to reason about than an algebraic expression.

Here is an example of a pure function:

fun abs(n: Int): Int = Math.abs(n)

Here is an example of an impure function:

class Burger(var eaten: Boolean) {
  fun eat() {
    this.eaten = true // changing the state is an example of a side-effect
  }
}

An Updated Guide to Maven Archetypes

Carter — Mon, 11 Mar 2024 15:38:16 +0000

About-Maven-Archetypes

What is the point?

One of the major goals in programming is to harbour re-usability and scalability. One way in which we can reuse code is by creating a templating system that allows you to quickly get up and running with predefined code that you're confident in. Maven archetypes one example of this system in action.

How do I create my own?

You can create your own Maven Archetype by using a Maven Archetype! Using the predefined org.apache.maven.archetypes:maven-archetype-archetype. Make sure you choose the archetype from Maven Central, as it has the most up-to-date version. You can also safely delete the test directory of the root folder as we this is simply a demonstration. Once you've done that, you can expect the following project structure.

my-archetype/
|-- src/
|   |-- main/
|   |   |-- resources/
|   |   |   |-- archetype-resources/
|   |   |   |   |-- src/
|   |   |   |       |-- main/
|   |   |   |           |-- java/
|   |   |   |           |   |-- App.java
|   |   |   |           |-- test/
|   |   |   |           |   |-- TestApp.java
|   |   |   |-- META-INF/
|   |   |       |-- maven/
|   |   |           |-- archetype-meta.xml  
|   |   |                   
|   |   |-- pom.xml
|-- pom.xml

archetype-meta.xml

archetype.meta.xml provides metadata for your archetype such as definitions for folder locations and how they should behave. More specifically, this is where you will define the expected layout
of your source files, tests, and other properties that you will use in your project. Those files are created directly by you in the archetype-resources folder.

<archetype-descriptor xmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.0.0 http://maven.apache.org/xsd/archetype-descriptor-1.0.0.xsd"  
  name="${artifactId}">

  <fileSets> <!-- fileSets are used to denote some arbitrary group of folders in your project. -->
      <!-- per maven project specification, you should have a directory for your java source files -->
    <fileSet filtered="true" packaged="true">
      <directory>src/main/java</directory>                                                                                                                           
    </fileSet>                                                                                       
      <!-- and a directory for your test files -->
    <fileSet filtered="true" packaged="true">                                                                                                                        
      <directory>src/test/java</directory>                                                                                                                           
    </fileSet>                                                                                                                                                       
  </fileSets>
</archetype-descriptor>

Filtered & Packaged attributes

filtered - You will be using property binding in the java source files to
bootstrap any required properties.

packaged - the fileset will be prepended to the package or group-id of the newly created
project.

Required Properties

Required properties allow you to specify parameters that will
be queried to the user when building your archetype with the help of mvn achetype:generate. These properties can have a defaultValue which will be used if the user does not input any value. these properties are interpolated into the scaffold created in archetype-resources. You can learn more about this templating is done by checking out the Apache Velocity Project

<requiredProperties>
    <requiredProperty key="about">
        <defaultValue>no about specified</defaultValue>
    </requiredProperty>
    <requiredProperty key="color"/>
    <requiredProperty key="due-date">
        <defaultValue>10 days from today</defaultValue>
    </requiredProperty> 
</requiredProperties>

here we create a few required properties. Only color will be required by mvn command but all will be queried if interactive mode is remained on.

Defining Properties

To define properties, we use the following syntax:

${name-of-property}

Here is our example template locate in src/main/resources/archetype-resources/main/java/

package $package;

/**
 *
 *  ${about}
 *  due-date: ${due-date}
 */
public class App
{
    public static void main( String[] args )
    {
        System.out.println("Your favorite color is ${color}");
    }
}

Installing

Installing is a matter of calling mvn clean install to install the archetype to our local repository, .m2/repository, which can be found as a hidden folder under your user directory.

Generating a project using the Archetype & Final Result

Now it's time to finally generate the template and retrieve it from our
local repository which will be referenced automatically when we call mvn achetype:generate

mvn archetype:generate
    -DgroupId=com.example \
    -DartifactId=my-archetype-created \
    -DarchetypeArtifactId=my-new-maven-archetype \
    -DarchetypeGroupId=org.example \
    -DarchetypeVersion=1.0-SNAPSHOT \
    -DinteractiveMode=false \
    -Dcolor=red \
    -Ddue-date=09/05/2023 \
    -Dabout='This project was created using Maven Archetypes, and this text is from the command line'

This command will generate the project in the current directory
using your artifact id (my-archetype-created in the above example). Now that we have are project set, we can view the templating taken place in App.java

package com.example;

/**
 *
 *  This project was created using Maven Archetypes, and this text is from the command line
 *  due-date: 09/05/2023
 */
public class App
{
    public static void main( String[] args )
    {
        System.out.println("Your favorite color is red");
    }
}