/*****************************************************************

Exercise Number: 1
******************************************************************/

Program:
import java.util.ArrayList;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
ArrayList<Integer> numbers = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
System.out.println("Enter the number of elements: ");
int numElements = scanner.nextInt();
System.out.println("Enter the elements: ");
for (int i = 0; i<numElements; i++)
{
int element = scanner.nextInt();
numbers.add(element);
}
System.out.println("Contents of the ArrayList:");
for (int i = 0; i<numbers.size(); i++) {
System.out.println(numbers.get(i));
}
scanner.close();
}
}

/*****************************************************************
Exercise Number: 2
******************************************************************/
Program:
import java.util.HashSet;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)

{
HashSet<String>stringSet = new HashSet<>();
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of elements: ");
int n = scanner.nextInt();
scanner.nextLine();
System.out.println("Enter " + n + " elements:");
for (int i = 0; i< n; i++)
{
System.out.print("Enter element " + (i + 1) + ": ");
String element = scanner.nextLine().trim();
stringSet.add(element);
}
System.out.println("Contents of the HashSet:");

for (String element : stringSet)

 {
System.out.println(element);
}

System.out.print("Enter an element to check its presence: ");

String elementToCheck = scanner.nextLine();
booleancontainsElement = stringSet.contains(elementToCheck);
System.out.println(elementToCheck + " is in the HashSet: " + containsElement);
System.out.print("Enter an element to remove: ");
String elementToRemove = scanner.nextLine();
boolean removed = stringSet.remove(elementToRemove);

System.out.println(elementToRemove + " removed from the HashSet: " + removed);

System.out.println("Contents of the HashSet:");
for (String element : stringSet)
{
System.out.println(element);
}
scanner.close();
}
}

/*****************************************************************
Exercise Number: 3
******************************************************************/
Program:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main

{
public static void main(String[] args)
{
String sourceFilePath = "source.txt";
String targetFilePath = "target.txt";
try (FileInputStreamfis = new FileInputStream(sourceFilePath);
FileOutputStreamfos = new FileOutputStream(targetFilePath))
{
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1)
{
fos.write(buffer, 0, bytesRead);
}
System.out.println("File copied successfully.");
}
catch (IOException e)
{
System.err.println("An error occurred: " + e.getMessage());
}
}
}
/*****************************************************************
Exercise Number: 4
******************************************************************/

Program:
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Integer> numbers = new ArrayList<>();

System.out.println("Enter the number of integers:");

int n=sc.nextInt();
System.out.println("Enter the integer values:");
for(int i=0;i<n;i++){
numbers.add(sc.nextInt());
}
List<Integer>evenNumbers = numbers.stream()
.filter(j -> j % 2 == 0)
.collect(Collectors.toList());

System.out.println("Even numbers: " + evenNumbers);

sc.close();
}
}

Exercise Number: 5
Program:
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Double> numbers = new ArrayList<>();
System.out.println("Enter the number of input:");
int n=sc.nextInt();
System.out.println("Enter the floating point numbers:");
for(int i=0;i<n;i++){
numbers.add(sc.nextDouble());
}
double average = numbers.stream()
.mapToDouble(Double::doubleValue)
.average()
.orElse(0.0);

System.out.println("Average: " + average);

sc.close();
}
}

/*****************************************************************
Exercise Number: 6
******************************************************************/
Program:
import java.util.Scanner;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.stream.Stream;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter the path:");
String filePath = sc.nextLine();
System.out.println("Enter the word whose occurence
should be counted:");
String targetWord = sc.nextLine();
try {
long wordCount = countWordOccurrences(filePath,
targetWord);
System.out.println("The word '" + targetWord + "' appears " + wordCount +
" times in the file.");
} catch (IOException e) {
e.printStackTrace();
}
}
public static long countWordOccurrences(String filePath, String targetWord)
throws IOException {
try (Stream<String> lines = Files.lines(Path.of(filePath))) {
return lines
.flatMap(line ->Stream.of(line.split("\\s+")))
.filter(word ->word.equals(targetWord))
.count();
}
}
}

/*****************************************************************
Exercise Number: 7
******************************************************************/
Program:
public class PalindromeChecker
{

public static booleanisPalindrome(String str)

{
str = str.replaceAll("\\s", "").toLowerCase();

int left = 0;
 int right = str.length() - 1;

while (left < right)

{
if (str.charAt(left) != str.charAt(right))
{
return false;
}
left++;
right--;
}

return true;
}
}

JUnit test case program:

import static org.junit.Assert.*;

import org.junit.Test;

public class PalindromeCheckerTest {

@Test
public void testIsPalindromeWithPalindrome() {
String palindrome = "racecar";
assertTrue(PalindromeChecker.isPalindrome(palindrome));
}

@Test
public void testIsPalindromeWithNonPalindrome() {
String nonPalindrome = "hello";
assertFalse(PalindromeChecker.isPalindrome(nonPalindrome));
}

@Test
public void testIsPalindromeWithEmptyString() {
String emptyString = "";
assertTrue(PalindromeChecker.isPalindrome(emptyString));
}

@Test
public void testIsPalindromeWithNullString() {
String nullString = null;
assertTrue(PalindromeChecker.isPalindrome(nullString));
}
}

/*****************************************************************
Exercise Number: 8
******************************************************************/

Program:
public class FactorialCalculator
{
public static long calculateFactorial(int n)
{
if (n < 0)
{
throw new IllegalArgumentException("Factorial is not defined for negative
numbers.");
}
else if (n == 0)
{
return 1;
}
else
{
return n * calculateFactorial(n - 1);}
}
}
JUnit test case program:
public class FactorialCalculatorTest {
@Test
public void testFactorialWithPositiveNumber() {
assertEquals(120, FactorialCalculator.calculateFactorial(5));
}
@Test
public void testFactorialWithZero() {
assertEquals(1,
FactorialCalculator.calculateFactorial(0));
}
@Test
public void testFactorialWithNegativeNumber() {
AssertEquals(-1, FactorialCalculator.calculateFactorial(-5));
}
}

/*****************************************************************
Exercise Number: 9
******************************************************************/

Program:
public class Calculator
{
public static int divide(int numerator, int denominator)
{
if (denominator == 0)
{
throw new ArithmeticException("Cannot divide by zero");
}
return numerator / denominator;
}
}
JUnit test case program:
import static org.junit.Assert.*;
import org.junit.Test;

public class CalculatorTest

{
@Test(expected = ArithmeticException.class)
public void testDivideByZero()
{
int numerator = 10;
int denominator = 0;
int result = Calculator.divide(numerator, denominator);
}
}

/*****************************************************************
Exercise Number: 10
******************************************************************/

Program:
App.java
package com.hibers.DemoHib;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class App
{
public static void main( String[] args )
{
Student s1=new Student();
s1.setSid(1);
s1.setSname("Kaviya");
s1.setSdob("100");
Configuration con = new
Configuration().configure().addAnnotatedClass(Student.class);

SessionFactory sf=con.buildSessionFactory();
Session session=sf.openSession();
Transaction tx=session.beginTransaction();

session.save(s1);
tx.commit();
}
}

Student.java
package com.hibers.DemoHib;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Student
{
@Id
 private int sid;
private String sname;
private String sdob;
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSdob() {
return sdob;
}
public void setSdob(String sdob) {
this.sdob = sdob;
}
}

Pom.xml:
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.10.Final</version>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.0.33</version>
</dependency>

/*****************************************************************
Exercise Number: 11
******************************************************************/
Program:
App.java
package com.hibers.DemoHib;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class App
{
public static void main( String[] args )
{
Student s1=new Student();
s1.setSid(1);
s1.setSname("Kaviya");
s1.setSdob("100");
Configuration con=new
Configuration().configure().addAnnotatedClass(Student.class);
 SessionFactory sf=con.buildSessionFactory();
Session session=sf.openSession();
Transaction tx=session.beginTransaction();

session.save(s1);
tx.commit();
}
}

Student.java

package com.hibers.DemoHib;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Student
{
@Id
private int sid;
private String sname;
private String sdob;
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSdob() {
return sdob;
}
public void setSdob(String sdob) {
this.sdob = sdob;
}
}

Pom.xml

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
 <version>5.4.10.Final</version>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.0.33</version>
</dependency>

Hibernate.cfg.xml:

<property name="hbm2ddl.auto">update</property>
<property name="hbm2ddl.auto">delete</property>
<property name="hbm2ddl.auto">create</property>

/*****************************************************************
Exercise Number: 12
******************************************************************/

Program:
App.java
package com.Example.Examplehib;
import org.hibernate.cfg.Configuration;
import org.hibernate.*;
public class App
{
public static void main( String[] args )
{
Configuration con=new
Configuration().configure().addAnnotatedClass(Alien.class);
//ServiceRegistry reg=new
ServiceRegistryBuilder().applySetting(con.getProperties());
SessionFactory sf=con.buildSessionFactory();
Session s=sf.openSession();
Transaction tx=s.beginTransaction();
//s.save(a);
a=(Alien)s.get(Alien.class, 100);
tx.commit();
System.out.println(a);
*/
Laptop l=new Laptop();
l.setLid(100);
l.setLname("HP");
Robo r=new Robo();
r.setRollno(1);
r.setName("bheem");
 r.setMarks(50);
r.getL().add(l);
Configuration con=new
Configuration().configure().addAnnotatedClass(Robo.class).addAnnotatedClass(Laptop.
class);
SessionFactory sf=con.buildSessionFactory();
Session s=sf.openSession();
s.beginTransaction();
s.save(l);
s.save(r);
s.getTransaction().commit();
}
}
Robo.java
package com.Example.Examplehib;
import java.util.*;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.*;
@Entity
public class Robo {
@Id
private int rollno;
private String name;
@OneToMany(mappedBy="r")
private List<Laptop> l=new ArrayList<Laptop>();
public int getRollno() {
return rollno;
}
public void setRollno(int rollno) {
this.rollno = rollno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMarks() {
return marks;
}
public void setMarks(int marks) {
this.marks = marks;
}
public List<Laptop>getL() {
return l;
}
public void setL(List<Laptop> l) {
this.l = l;
}
@Override
public String toString() {
return "Robo [rollno=" + rollno + ", name=" + name +
", marks=" + marks + "]";
}
}
Laptop.java:
package com.Example.Examplehib;
import javax.persistence.Entity;
import javax.persistence.*;
@Entity
public class Laptop {
@Id
private int lid;
private String lname;
@ManyToOne
private Robo r;
public int getLid() {
return lid;
}
public void setLid(int lid) {
this.lid = lid;
}
public String getLname() {
return lname;
}
public void setLname(String lname) {
this.lname = lname;
}
}

/*****************************************************************
Exercise Number: 13
******************************************************************/
Program:
App.java
package com.hibers.DemoHib;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class App
{
public static void main( String[] args )
{
try {
Student s1=new Student();
s1.setSid(1);
s1.setSname("Kaviya");
s1.setSdob("100");
Configuration con=new
Configuration().configure().addAnnotatedClass(Student.class);

SessionFactory sf=con.buildSessionFactory();
Session session=sf.openSession();
Transaction tx=session.beginTransaction();
session.save(s1);
tx.commit();
System.out.println("Transaction committed successfully!");
} catch (Exception e) {
e.printStackTrace();
tx.rollback(); // Rollback the transaction if an error occurs
System.out.println("Transaction rolled back due to an error!");
} finally {
session.close();
sf.close(); }
}
}

Student.java

package com.hibers.DemoHib;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Student
{
@Id
private int sid;
private String sname;
private String sdob;
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSdob() {
return sdob;
}
public void setSdob(String sdob) {
this.sdob = sdob;
}

Pom.xml:
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.10.Final</version>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.0.33</version>
</dependency>

/*****************************************************************
Exercise Number: 14
******************************************************************/
Program:
App.java:
package com.hibers.DemoHib;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class App
{
public static void main( String[] args )
{
Configuration con=new
Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Student.class);
SessionFactory sf=con.buildSessionFactory();
Session session=sf.openSession();
Transaction tx=session.beginTransaction();

// Perform database operations

tx.commit();
session.close();
sf.close();
}
}

ehcache.xml:

<ehcachexmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://www.ehcache.org/ehcache.xsd"
updateCheck="false">

<diskStore path="java.io.tmpdir" />

<defaultCache
maxEntriesLocalHeap="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
maxEntriesLocalDisk="10000000"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU" />

</ehcache>

Pom.xml:

<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.10.7</version><!-- Use the latest version -->
</dependency>
/*****************************************************************
Exercise Number: 15
******************************************************************/

Program:
App.java
package com.hibernatespring;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com. hibernatespring.service.UserService;
import com. hibernatespring.service.UserServiceImpl;
public class App {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new
AnnotationConfigApplicationContext(AppConfig.class);
UserServiceuserService =
context.getBean("userServiceImpl",UserServiceImpl.class);
userService.save();
// Close the context
context.close();
}
}
AppConfig.java
package com. hibernatespring;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@ComponentScan("com.hibernatespring ")
@EnableTransactionManagement
public class AppConfig {

@Bean
public LocalSessionFactoryBeansessionFactory() {
LocalSessionFactoryBeansessionFactory = new LocalSessionFactoryBean();
sessionFactory.setDataSource(dataSource());
sessionFactory.setPackagesToScan("com. hibernatespring.models");
sessionFactory.setHibernateProperties(hibernateProperties());
return sessionFactory;
}
@Bean
public DataSourcedataSource() {
BasicDataSourcedataSource = new BasicDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/springwithdb?useSSL=false");
dataSource.setUsername("user-name");
dataSource.setPassword("password");
return dataSource;
}
@Bean
public PlatformTransactionManagerhibernateTransactionManager() {
HibernateTransactionManagertransactionManager
= new HibernateTransactionManager();
transactionManager.setSessionFactory(sessionFactory().getObject());
return transactionManager;
}
private final Properties hibernateProperties() {
Properties hibernateProperties = new Properties();
hibernateProperties.setProperty("hibernate.show_sql","true");
return hibernateProperties;
}
}
UserDao.java
package com.hibernatespring.dao;

public interface UserDao {

void save();
}
UserDaoImpl.java
package com.hibernatespring.dao
import javax.transaction.Transactional;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com. hibernatespring.models.User;
@Repository
public class UserDaoImpl implements UserDao{
@Autowired
private SessionFactorysessionFactory;
@Transactional
public void save() {
Session session = sessionFactory.getCurrentSession();
User user = new User(101,"Sam","Jacob","sam@ hibernatespring.com");
session.save(user);
}
}.
User.java
package com.hibernatespring.models;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
int id;
String name;
String lastName;
 String email;

public User(int id, String name, String lastName, String email) {

//super();
this.id = id;
this.name = name;
this.lastName = lastName;
this.email = email;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}

UserService.java
package com. hibernatespring.service;

public interface UserService {

void save();
}

UserServiceImpl.java
package com.hibernatespring.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.hibernatespring.dao.UserDao;

@Service
public class UserServiceImpl implements UserService{

@Autowired
private UserDaouserDao;

public void save() {

userDao.save();
}
}
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com. hibernatespring</groupId>
<artifactId>springhibernate</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-web
-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Hibernate -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>

<!-- MySQL -->

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.connector.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-dbcp</artifactId>
<version>9.0.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.195</version>
</dependency>
</dependencies>
<properties>
<spring.version>5.2.8.RELEASE</spring.version>
<hibernate.version>5.4.1.Final</hibernate.version>
 <mysql.connector.version>5.1.45</mysql.connector.version>

</properties>
</project>

/*****************************************************************
Exercise Number: 16
******************************************************************/

PROGRAM:
Step 2:
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0</version>
</dependency>

Step 4:
Person.java file :
package com.lakshita.springdemo;
public interface Person {
void viewRole();
}

Employee.java file :
package com.lakshita.springdemo;
import org.springframework.stereotype.Component;
@Component
public class Employee implements Person {

private int id;

private String name;
private String role;
public Employee()
{System.out.println("def cons");}
public Employee(int id, String name,String role) {
this.id = id;
this.name = name;
this.role=role;
}
@Override
 public String toString() {
return "Employee [id=" + id + ", name=" + name + ", role=" + role
+ "]";
}
public void viewRole(){
System.out.println(role);
}
}
Step 5:
applicationContext.xml File:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-
beans.xsd">

<bean id="emp1" class="com.lakshita.springdemo.Employee">

<constructor-arg value="101" type="int"></constructor-arg>
<constructor-arg value="Lakshita"></constructor-arg>
<constructor-arg value="supervisor"></constructor-arg>
</bean>
</beans>
Step 6:
App.java File
package com.lakshita.springdemo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App
{
public static void main( String[] args )
{
ApplicationContext context=new
ClassPathXmlApplicationContext("applicationContext.xml");

Person p1=(Employee)context.getBean("emp1");
p1.viewRole();
System.out.println(p1);

}
}

/*****************************************************************
Exercise Number: 17
******************************************************************/
Program:
Step 2:
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0</version>
</dependency>
</dependencies>

Step 3:
Vehicle.java
package com.lakshita.springdemo;
public interface Vehicle {
void drive_process();
}

Step 4:
Engine.java file
package com.lakshita.springdemo;
import java.util.*;
import org.springframework.stereotype.Component;
@Component
public class Engine {
public static List<String> engines=new ArrayList<String>();
static {
engines.add("Fan");
engines.add("Fuel Tank");
engines.add("Sensor");
engines.add("Water plump");
}

public List<String>getList(){
return engines;
}
}

Step 5:
Car.java File
import org.springframework.stereotype.Component;
@Component
public class Car implements Vehicle {
@Autowired
private Engine engine;

public List<String>view_engine() {
return engine.getList();
}
public void drive_process() {
System.out.println("Driving.....");
}
}

Step 6:
AppConfig.java file
package com.lakshita.springdemo;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
package com.lakshita.springdemo;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.lakshita.springdemo")
public class AppConfig {
//Do your startup Configurations
}
Step 7:
App.java File
package com.lakshita.springdemo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App

{
public static void main( String[] args )
{
ApplicationContext context = new
AnnotationConfigApplicationContext(AppConfig.class);

Car c1=context.getBean(Car.class);
System.out.println(c1.view_engine());
}
}

/*****************************************************************
Exercise Number: 18
******************************************************************

PROGRAM:

Step 2:
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0</version>
</dependency>
</dependencies>
Step 3:
Employee.java File
package com.lakshita.springdemo;
public class Employee {

private int id;

private String name;
private Address address;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
 @Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", address=" +
address + "]";
}
}

Step 4:
Address.java File
package com.lakshita.springdemo;

public class Address {

private String state;
private String city;

public String getState() {

return state;
}
public void setState(String state) {
this.state = state;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
@Override
public String toString() {
return "Address [state=" + state + ", city=" + city + "]";
}

Step 5:
applicationContext.xml File
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="employee" class="com.lakshita.springdemo.Employee">
<property name="id" value="101"></property>
<property name="name" value="Lakshita"></property>
<property name="address">
<bean class="com.lakshita.springdemo.Address">
<property name="state" value="Chennai"></property>
<property name="city" value="TamilNadu"></property>
</bean>
</property>
</bean>
</beans>
Step 6:
App.java File
package com.lakshita.springdemo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App
{
 public static void main( String[] args )
{
ApplicationContext context = new
ClassPathXmlApplicationContext("applicationContext.xml");

Employee emp=(Employee)context.getBean("employee");
System.out.println(emp);
}
}

/*****************************************************************
Exercise Number: 19
******************************************************************/

Program:
Step 1: Create a model for the registration form (`RegistrationForm.java`):
public class RegistrationForm {
private String name;
private String email;
private String password;
// Getters and setters
}
Step 2: Create a controller (`RegistrationController.java`):
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
@Controller
public class RegistrationController {
@GetMapping("/register")
public String showRegistrationForm(Model model) {
model.addAttribute("registrationForm", new RegistrationForm());
return "registration-form";
}
@PostMapping("/register")
public String processRegistrationForm(
@Valid @ModelAttribute("registrationForm") RegistrationForm form,
BindingResultbindingResult) {
if (bindingResult.hasErrors()) {
return "registration-form";
}
// Perform registration logic here (e.g., store the user in a database).
return "registration-success";
}
}

Step 3: Create the registration form view (`registration-form.jsp`):

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-
8" %>
<!DOCTYPE html>
<html>
<head>
<title>Registration Form</title>
</head>
<body>
<h2>Registration Form</h2>
<form action="/register" method="post" modelAttribute="registrationForm">
<label for="name">Name:</label>
<input type="text" id="name" name="name" />
<br/>
<label for="email">Email:</label>
<input type="text" id="email" name="email" />
<br/>
<label for="password">Password:</label>
<input type="password" id="password" name="password" />
<br/>
<input type="submit" value="Register" />
</form>
</body>
</html>
Step 4: Create the success view (`registration-success.jsp`):
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-
8" %>
<!DOCTYPE html>
<html>
<head>
<title>Registration Success</title>
</head>
<body>
<h2>Registration Successful!</h2>
</body>
</html>
Step 5: Configure Spring MVC and validation in your `web.xml` and Spring
configuration files.
Step 5.1: Configure Spring MVC and Validation
5.1. Create a Spring Configuration Class:
In your Spring MVC application, create a configuration class that specifies Spring
MVC settings. This class typically extends
`WebMvcConfigurerAdapter`. If you are using Spring Boot,
this configuration may be handled automatically.
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

// Configure a message source, view resolver, and other MVC-related

settings.

// To enable validation, configure a Validator bean, e.g., the

LocalValidatorFactoryBean.
@Bean
public javax.validation.ValidatorlocalValidatorFactoryBean() {
return new LocalValidatorFactoryBean();
}
}
Step 5.2: Enable Validation in Your Controller:
In your controller, enable validation by adding the `@Valid` annotation to the
model attribute that you want to validate.
@PostMapping("/register")
 public String processRegistrationForm(
@Valid @ModelAttribute("registrationForm") RegistrationForm form,
BindingResultbindingResult) {
// Your validation logic
}
Step 5.3: Define Validation Rules
To define validation rules for the `RegistrationForm` class, you can use
annotations from the `javax.validation.constraints` package.
For example, to require that the `name` field is not empty, use the `@NotBlank`
annotation:

import javax.validation.constraints.NotBlank;
// ...

public class RegistrationForm {

@NotBlank(message = "Name is required")
private String name;
// ...
}
Step 5.4: Display Validation Errors in the View:

To display validation errors in your registration form view, you can access them
through the `BindingResult` object in your
controller method. For each field, you can use the `<form:errors>`
tag in your JSP view to display the error message.
<form:form action="/register" method="post" modelAttribute="registrationForm">
<form:label path="name">Name:</form:label>
<form:input path="name" />
<form:errors path="name" cssClass="error" />
<!-- Other form fields and error messages -->
</form:form>
Step 5.5: Set Up Message Source for Internationalization:
If you want to support internationalization and provide localized error messages,
you can configure a message source bean.
This step is optional but useful for localization.
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import
org.springframework.context.support.ReloadableResourceBundleMessageSource;
@Configuration
public class WebConfig {
// Other configuration

@Bean
public MessageSourcemessageSource() {
ReloadableResourceBundleMessageSourcemessageSource = new
ReloadableResourceBundleMessageSource();
messageSource.setBasename("classpath:messages");
messageSource.setDefaultEncoding("UTF-8");
return messageSource;
}
}
Step 5.6: Create Validation Error Messages:
Define validation error messages in properties files (e.g., `messages.properties`).
These messages should correspond to the
validation annotations and
can be localized for different languages.
Example `messages.properties`:
NotBlank.registrationForm.name=Name is required
Step 5.7: Configure Spring to Use Validation and MessageSource:
In your Spring configuration, make sure to configure Spring to use validation and
the message source.
Example Spring XML Configuration (`spring-servlet.xml`):
<mvc:annotation-driven />
<bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<property name="basename" value="classpath:messages" />
<property name="defaultEncoding" value="UTF-8" />
</bean>
Step 5.8: Run Your Application:
After configuring Spring MVC and validation, run your application and access the
registration form. When you submit the form with
validation errors, you should see the error messages displayed next
to the corresponding form fields. When the form is
successfully submitted, you can process the registration logic.
This detailed setup will enable Spring MVC and validation in your
registration form. It allows you to define validation rules,
handle errors, and display appropriate messages to users.
Step 6:
Run the application and access it at `http://localhost:8080/your-app/register`.

/*****************************************************************
Exercise Number: 20
******************************************************************/

Program:
Step 1: Set up the Spring MVC Project
Set up a Spring MVC project with your preferred build tool and database
configuration.
Step 2: Define the Data Model
Create a Java class to represent the data you want to retrieve. For example, let's
say we're working with a simple "Product" entity.
public class Product {
private Long id;
private String name;
private double price;
// Getters and setters
}
Step 3: Data Access Layer
Create a data access layer to fetch data from the database. You can use Spring Data
JPA or other database access methods.
Here's a
simple example using Spring Data JPA:
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
// Define custom query methods if needed
}
Step 4: Controller
Create a controller to handle requests and populate the model with data from the
database.
@Controller
public class ProductController {

@Autowired
private ProductRepositoryproductRepository;

@GetMapping("/products")
public String listProducts(Model model) {
List<Product> products = productRepository.findAll();
model.addAttribute("products", products);
return "product-list";
}
}
Step 5: Create the View
Create a JSP view (e.g., `product-list.jsp`) to display the data.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-
8" %>
<!DOCTYPE html>
<html>
<head>
<title>Product List</title>
</head>
<body>
<h2>Product List</h2>
<table>
<tr>
<th>ID</th>
<th>Name</th>
<th>Price</th>
</tr>
<c:forEach items="${products}" var="product">
<tr>
<td>${product.id}</td>
<td>${product.name}</td>
<td>${product.price}</td>
</tr>
</c:forEach>
</table>
</body>
</html>
Step 6: Configuration
Configure Spring MVC, database connection, and other dependencies in your Spring
configuration files (e.g., `web.xml`,
`servlet-
context.xml`, and `application-context.xml`).
Step 7: Run the Application
Run your Spring application and access the product list at
`http://localhost:8080/your-app/products`.

Exercise Number : 21
Program:
Step 1: Set up the Spring MVC Project
Set up a Spring MVC project with your preferred build tool.
Step 2: Configure Spring Security
Configure Spring Security in your Spring configuration files. You can define
security configurations using Java configuration or XML.
Here's an
example using Java configuration:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private CustomUserDetailsServiceuserDetailsService;
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception
{
auth.userDetailsService(userDetailsService)
.passwordEncoder(passwordEncoder());
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/public/**").permitAll()
.antMatchers("/user/**").hasRole("USER")
.antMatchers("/admin/**").hasRole("ADMIN")
.and()
.formLogin()
.loginPage("/login")
.defaultSuccessURL("/user/home")
.and()
.logout()
.logoutSuccessUrl("/login?logout")
.and()
.exceptionHandling()
.accessDeniedPage("/403");
}

@Bean
public PasswordEncoderpasswordEncoder() {
return new BCryptPasswordEncoder();
}
}
Step 3: Define Security Rules and Access Control
In the configuration, you define security rules for URL patterns and specify which
roles are allowed to access them.
Step 4: User and Role Entities
Create user and role entities to store user and role information. You can use
Spring Data JPA or other database access methods.
Step 5: Implement User Authentication and Registration
Implement user authentication using a custom `UserDetailsService` and provide a
registration process to create new user accounts.
Step 6: Create Secure Pages
Create secure pages (e.g., `user/home.jsp`, `admin/dashboard.jsp`) and make them
accessible only to authenticated users with specific roles.
Step 7: Configuration
Configure Spring MVC, database connection, and other dependencies in your Spring
configuration files.
Step 8: Run the Application
Run your Spring application and access secured pages based on user roles.