Basics

$ spring --version
$ spring shell		#for auto-completion using TAB
$ spring init
$ spring init -dweb,jpa,security --build gradle output_folder # default is Maven
$ spring init -dweb,jpa -p war	# packaging as WAR instead of JAR default

pom.xml

src.main.java
			com.example.demo
				 DemoApplication.java
				 controller/
				 dto/
				 repository/impl
				 service/impl

src.main.resources/
			application.properties
			static/
			templates/

src.test.java
			com.demo
				  DemoApplicationTest.java

@SpringBootApplication				// configuration
public class DemoApplication {
public static void main(String[] args) {
	SpringApplication.run(DemoApplication.class, args);		// bootstrapping; passing object of current class
}

@ConditionalOnBean(name={"dataSource"})
@ConditionalOnBean(type={DataSource.class})
@ConditionalOnMissingBean(DataSource.class)

@ConditionalOnProperty
@ConditionalOnMissingBean
@ConditionalOnMissingClass

// 1. define our own DataSource Bean in any @Configuration class, Spring Boot will automatically register it
@Bean
public AnotherClass myDataSource() {		// name doesn't matter; only return type does
	return new DataSource();
}

# 2. customize default DataSource class using properties

# Connection settings
spring.datasource.url=
spring.datasource.username=
spring.datasource.password=
spring.datasource.driver-class-name=

# Connection pool settings
spring.datasource.initial-size=
spring.datasource.max-active=
spring.datasource.max-idle=
spring.datasource.min-idle=

# web embedded server configuration
server.port=9000
server.address=192.168.11.21
server.session-timeout=1800

# change base path for server
server.servlet.context-path=/vendormanagement

@Configuration
@EnableAutoConfiguration(exclude=DataSourceAutoConfiguration.class)
public class ApplicationConfiguration {
	// code
}

# define any custom property and use it
foo.bar=1337

foo.bar=${FOOBAR}

first.name=Abhishek
foo.bar=My name is ${first.name}

# supplying a default
foo.bar=${number:420}

# via command-line arg
java -jar demo-app.jar --FOOBAR=Abhishek

# via env variables
set FOOBAR=Abhishek
java -jar demo-app.jar

# we often configure helm charts in production to supply them

public static void main(String[] args) {
	System.setProperty("spring.config.name", "foobar");		// file is automatically named "foobar.properties"
	SpringApplication.run(MasteringSpringBootApplication.class, args);
}

// another way to do it via command line
$ java -jar myproject.jar --spring.config.name=foobar

// POJO
@Component
@ConfigurationProperties(prefix="demo")
public class Demo {
	private String foo;
	private String bar;

	public void setFoo(String foo) {
		this.foo = foo;
	}
	public String getFoo() {
		return foo;
	}

	public void setBar(String bar) {
		this.bar = bar;
	}
	public String getBar() {
		return bar;
	}
}

// property
demo.foo="Lorem"
demo.bar="Ipsum"

// we can now use getter and setter in other classes to use this POJO
// we can also have List, Map, or other POJOs inside ConfigurationProperties classes

// we can also use @ConfigurationProperties on record instead of a class; makes the code much shorter
@ConfigurationProperties(prefix="demo")
public record Demo (String foo, String bar){ }

# 1. setting the property in application.properties (default)
spring.profiles.active=dev

# 2. or select a profile by executing the JAR with param
--spring.profiles.active=dev 

<!-- 3. or activating profile with POM -->
<plugins>
    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
            <profiles>
                <profile>dev</profile>
            </profiles>
        </configuration>
    </plugin>
</plugins>

spring.profiles.active=dev,qa

$ java -jar foobar-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

// property
foo.bar = "FoobarStr"

// in class code
@Value("${foo.bar}")
private String foobar;

@Value("${foo.bar: defaultStr}")	 // with a default value
private String foobar;

// we can't use @Value on a static variable, if we use, variable will be null at runtime
// we can directly use "${foo.bar}" at some limited places in our code

# all of the below are equivalent

example.property=true
example.property=on
example.property=yes
example.property=1

# Dot Separated
foo.bar.baz=qux

# Camel Case
fooBarBaz=qux

# Kebab Case
foo-bar-baz=qux

# Snake Case
foo_bar_baz=qux

# Mixed Usage
foo.bar-baz=qux

@PropertySource("classpath:foobar.properties")
public class foobarService{	 }

// note that we can't use YAML with this annotation out-of-the-box in Spring

# properties
database.host=localhost
database.user=admin

# yaml
database:
	host: localhost
	user: admin

# common to all profiles
database:
	host: localhost
	user: admin
---
# for dev profile
spring.profiles: dev
database:
	host: 1.1.1.1
	user: testuser
---
# for prod profile
spring.profiles: prod
database:
	host: 192.1.1.9
	user: user

$ mvn package

$ java -jar demo-app.jar --server.port=9090
$ java -Dserver.port=9090 -jar demo-app.jar

# need to use -D flag in the second approach
# since we're specifying to "java" executable (where flags should've been) and not to our JAR
# they both mean the same thing