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

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

Program:
import [Link];
import [Link];
public class Main
{
public static void main(String[] args)
{
ArrayList<Integer> numbers = new ArrayList<>();
Scanner scanner = new Scanner([Link]);
[Link]("Enter the number of elements: ");
int numElements = [Link]();
[Link]("Enter the elements: ");
for (int i = 0; i<numElements; i++)
{
int element = [Link]();
[Link](element);
}
[Link]("Contents of the ArrayList:");
for (int i = 0; i<[Link](); i++) {
[Link]([Link](i));
}
[Link]();
}
}

/*****************************************************************
Exercise Number: 2
******************************************************************/
Program:
import [Link];
import [Link];
public class Main
{
public static void main(String[] args)

{
HashSet<String>stringSet = new HashSet<>();
Scanner scanner = new Scanner([Link]);
[Link]("Enter the number of elements: ");
int n = [Link]();
[Link]();
[Link]("Enter " + n + " elements:");
for (int i = 0; i< n; i++)
{
[Link]("Enter element " + (i + 1) + ": ");
String element = [Link]().trim();
[Link](element);
}
[Link]("Contents of the HashSet:");

for (String element : stringSet)

 {
[Link](element);
}

[Link]("Enter an element to check its presence: ");

String elementToCheck = [Link]();
booleancontainsElement = [Link](elementToCheck);
[Link](elementToCheck + " is in the HashSet: " + containsElement);
[Link]("Enter an element to remove: ");
String elementToRemove = [Link]();
boolean removed = [Link](elementToRemove);

[Link](elementToRemove + " removed from the HashSet: " + removed);

[Link]("Contents of the HashSet:");
for (String element : stringSet)
{
[Link](element);
}
[Link]();
}
}

/*****************************************************************
Exercise Number: 3
******************************************************************/
Program:
import [Link];
import [Link];
import [Link];

public class Main

{
public static void main(String[] args)
{
String sourceFilePath = "[Link]";
String targetFilePath = "[Link]";
try (FileInputStreamfis = new FileInputStream(sourceFilePath);
FileOutputStreamfos = new FileOutputStream(targetFilePath))
{
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = [Link](buffer)) != -1)
{
[Link](buffer, 0, bytesRead);
}
[Link]("File copied successfully.");
}
catch (IOException e)
{
[Link]("An error occurred: " + [Link]());
}
}
}
/*****************************************************************
Exercise Number: 4
******************************************************************/

Program:
import [Link];
import [Link];
import [Link];
import [Link];

public class Main {

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

[Link]("Enter the number of integers:");

int n=[Link]();
[Link]("Enter the integer values:");
for(int i=0;i<n;i++){
[Link]([Link]());
}
List<Integer>evenNumbers = [Link]()
.filter(j -> j % 2 == 0)
.collect([Link]());

[Link]("Even numbers: " + evenNumbers);

[Link]();
}
}

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

[Link]("Average: " + average);

[Link]();
}
}

/*****************************************************************
Exercise Number: 6
******************************************************************/
Program:
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class Main {

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

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

public static booleanisPalindrome(String str)

{
str = [Link]("\\s", "").toLowerCase();

int left = 0;
 int right = [Link]() - 1;

while (left < right)

{
if ([Link](left) != [Link](right))
{
return false;
}
left++;
right--;
}

return true;
}
}

JUnit test case program:

import static [Link].*;

import [Link];

public class PalindromeCheckerTest {

@Test
public void testIsPalindromeWithPalindrome() {
String palindrome = "racecar";
assertTrue([Link](palindrome));
}

@Test
public void testIsPalindromeWithNonPalindrome() {
String nonPalindrome = "hello";
assertFalse([Link](nonPalindrome));
}

@Test
public void testIsPalindromeWithEmptyString() {
String emptyString = "";
assertTrue([Link](emptyString));
}

@Test
public void testIsPalindromeWithNullString() {
String nullString = null;
assertTrue([Link](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, [Link](5));
}
@Test
public void testFactorialWithZero() {
assertEquals(1,
[Link](0));
}
@Test
public void testFactorialWithNegativeNumber() {
AssertEquals(-1, [Link](-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 [Link].*;
import [Link];

public class CalculatorTest

{
@Test(expected = [Link])
public void testDivideByZero()
{
int numerator = 10;
int denominator = 0;
int result = [Link](numerator, denominator);
}
}

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

Program:
[Link]
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class App
{
public static void main( String[] args )
{
Student s1=new Student();
[Link](1);
[Link]("Kaviya");
[Link]("100");
Configuration con = new
Configuration().configure().addAnnotatedClass([Link]);

SessionFactory sf=[Link]();
Session session=[Link]();
Transaction tx=[Link]();

[Link](s1);
[Link]();
}
}

[Link]
package [Link];
import [Link];
import [Link];
@Entity
public class Student
{
@Id
 private int sid;
private String sname;
private String sdob;
public int getSid() {
return sid;
}
public void setSid(int sid) {
[Link] = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
[Link] = sname;
}
public String getSdob() {
return sdob;
}
public void setSdob(String sdob) {
[Link] = sdob;
}
}

[Link]:
<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-core</artifactId>
<version>[Link]</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.0.33</version>
</dependency>

/*****************************************************************
Exercise Number: 11
******************************************************************/
Program:
[Link]
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class App
{
public static void main( String[] args )
{
Student s1=new Student();
[Link](1);
[Link]("Kaviya");
[Link]("100");
Configuration con=new
Configuration().configure().addAnnotatedClass([Link]);
 SessionFactory sf=[Link]();
Session session=[Link]();
Transaction tx=[Link]();

[Link](s1);
[Link]();
}
}

[Link]

package [Link];
import [Link];
import [Link];
@Entity
public class Student
{
@Id
private int sid;
private String sname;
private String sdob;
public int getSid() {
return sid;
}
public void setSid(int sid) {
[Link] = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
[Link] = sname;
}
public String getSdob() {
return sdob;
}
public void setSdob(String sdob) {
[Link] = sdob;
}
}

[Link]

<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-core</artifactId>
 <version>[Link]</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.0.33</version>
</dependency>

[Link]:

<property name="[Link]">update</property>
<property name="[Link]">delete</property>
<property name="[Link]">create</property>

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

Program:
[Link]
package [Link];
import [Link];
import [Link].*;
public class App
{
public static void main( String[] args )
{
Configuration con=new
Configuration().configure().addAnnotatedClass([Link]);
//ServiceRegistry reg=new
ServiceRegistryBuilder().applySetting([Link]());
SessionFactory sf=[Link]();
Session s=[Link]();
Transaction tx=[Link]();
//[Link](a);
a=(Alien)[Link]([Link], 100);
[Link]();
[Link](a);
*/
Laptop l=new Laptop();
[Link](100);
[Link]("HP");
Robo r=new Robo();
[Link](1);
[Link]("bheem");
 [Link](50);
[Link]().add(l);
Configuration con=new
Configuration().configure().addAnnotatedClass([Link]).addAnnotatedClass(Laptop.
class);
SessionFactory sf=[Link]();
Session s=[Link]();
[Link]();
[Link](l);
[Link](r);
[Link]().commit();
}
}
[Link]
package [Link];
import [Link].*;
import [Link];
import [Link];
import [Link].*;
@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) {
[Link] = rollno;
}
public String getName() {
return name;
}
public void setName(String name) {
[Link] = name;
}
public int getMarks() {
return marks;
}
public void setMarks(int marks) {
[Link] = 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 + "]";
}
}
[Link]:
package [Link];
import [Link];
import [Link].*;
@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) {
[Link] = lid;
}
public String getLname() {
return lname;
}
public void setLname(String lname) {
[Link] = lname;
}
}

/*****************************************************************
Exercise Number: 13
******************************************************************/
Program:
[Link]
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class App
{
public static void main( String[] args )
{
try {
Student s1=new Student();
[Link](1);
[Link]("Kaviya");
[Link]("100");
Configuration con=new
Configuration().configure().addAnnotatedClass([Link]);

SessionFactory sf=[Link]();
Session session=[Link]();
Transaction tx=[Link]();
[Link](s1);
[Link]();
[Link]("Transaction committed successfully!");
} catch (Exception e) {
[Link]();
[Link](); // Rollback the transaction if an error occurs
[Link]("Transaction rolled back due to an error!");
} finally {
[Link]();
[Link](); }
}
}

[Link]

package [Link];
import [Link];
import [Link];
@Entity
public class Student
{
@Id
private int sid;
private String sname;
private String sdob;
public int getSid() {
return sid;
}
public void setSid(int sid) {
[Link] = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
[Link] = sname;
}
public String getSdob() {
return sdob;
}
public void setSdob(String sdob) {
[Link] = sdob;
}

[Link]:
<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-core</artifactId>
<version>[Link]</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.0.33</version>
</dependency>

/*****************************************************************
Exercise Number: 14
******************************************************************/
Program:
[Link]:
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class App
{
public static void main( String[] args )
{
Configuration con=new
Configuration().configure("[Link]").addAnnotatedClass([Link]);
SessionFactory sf=[Link]();
Session session=[Link]();
Transaction tx=[Link]();

// Perform database operations

[Link]();
[Link]();
[Link]();
}
}

[Link]:

<ehcachexmlns:xsi="[Link]
xsi:noNamespaceSchemaLocation="[Link]
updateCheck="false">

<diskStore path="[Link]" />

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

</ehcache>

[Link]:

<dependency>
<groupId>[Link]</groupId>
<artifactId>ehcache</artifactId>
<version>2.10.7</version><!-- Use the latest version -->
</dependency>
/*****************************************************************
Exercise Number: 15
******************************************************************/

Program:
[Link]
package [Link];
import [Link];
import com. [Link];
import com. [Link];
public class App {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new
AnnotationConfigApplicationContext([Link]);
UserServiceuserService =
[Link]("userServiceImpl",[Link]);
[Link]();
// Close the context
[Link]();
}
}
[Link]
package com. hibernatespring;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@Configuration
@ComponentScan("[Link] ")
@EnableTransactionManagement
public class AppConfig {

@Bean
public LocalSessionFactoryBeansessionFactory() {
LocalSessionFactoryBeansessionFactory = new LocalSessionFactoryBean();
[Link](dataSource());
[Link]("com. [Link]");
[Link](hibernateProperties());
return sessionFactory;
}
@Bean
public DataSourcedataSource() {
BasicDataSourcedataSource = new BasicDataSource();
[Link]("[Link]");
[Link]("jdbc:mysql://localhost:3306/springwithdb?useSSL=false");
[Link]("user-name");
[Link]("password");
return dataSource;
}
@Bean
public PlatformTransactionManagerhibernateTransactionManager() {
HibernateTransactionManagertransactionManager
= new HibernateTransactionManager();
[Link](sessionFactory().getObject());
return transactionManager;
}
private final Properties hibernateProperties() {
Properties hibernateProperties = new Properties();
[Link]("hibernate.show_sql","true");
return hibernateProperties;
}
}
[Link]
package [Link];

public interface UserDao {

void save();
}
[Link]
package [Link]
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import com. [Link];
@Repository
public class UserDaoImpl implements UserDao{
@Autowired
private SessionFactorysessionFactory;
@Transactional
public void save() {
Session session = [Link]();
User user = new User(101,"Sam","Jacob","sam@ [Link]");
[Link](user);
}
}.
[Link]
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

@Entity
@Table(name = "user")
public class User {
@Id
@GeneratedValue(strategy = [Link])
int id;
String name;
String lastName;
 String email;

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

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

[Link]
package com. [Link];

public interface UserService {

void save();
}

[Link]
package [Link];
import [Link];
import [Link];
import [Link];

@Service
public class UserServiceImpl implements UserService{

@Autowired
private UserDaouserDao;

public void save() {

[Link]();
}
}
[Link]
<project xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
<modelVersion>4.0.0</modelVersion>
<groupId>com. hibernatespring</groupId>
<artifactId>springhibernate</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<!-- [Link]
-->
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-core</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-context</artifactId>
<version>${[Link]}</version>
</dependency>
<!-- Hibernate -->
<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-core</artifactId>
<version>${[Link]}</version>
</dependency>

<!-- MySQL -->

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-tx</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>tomcat-dbcp</artifactId>
<version>9.0.1</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-orm</artifactId>
<version>${[Link]}</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.195</version>
</dependency>
</dependencies>
<properties>
<[Link]>[Link]</[Link]>
<[Link]>[Link]</[Link]>
 <[Link]>5.1.45</[Link]>

</properties>
</project>

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

PROGRAM:
Step 2:
<!-- [Link] -->
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0</version>
</dependency>

Step 4:
[Link] file :
package [Link];
public interface Person {
void viewRole();
}

[Link] file :
package [Link];
import [Link];
@Component
public class Employee implements Person {

private int id;

private String name;
private String role;
public Employee()
{[Link]("def cons");}
public Employee(int id, String name,String role) {
[Link] = id;
[Link] = name;
[Link]=role;
}
@Override
 public String toString() {
return "Employee [id=" + id + ", name=" + name + ", role=" + role
+ "]";
}
public void viewRole(){
[Link](role);
}
}
Step 5:
[Link] File:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
[Link]">

<bean id="emp1" class="[Link]">

<constructor-arg value="101" type="int"></constructor-arg>
<constructor-arg value="Lakshita"></constructor-arg>
<constructor-arg value="supervisor"></constructor-arg>
</bean>
</beans>
Step 6:
[Link] File
package [Link];
import [Link];
import [Link];
public class App
{
public static void main( String[] args )
{
ApplicationContext context=new
ClassPathXmlApplicationContext("[Link]");

Person p1=(Employee)[Link]("emp1");
[Link]();
[Link](p1);

}
}

/*****************************************************************
Exercise Number: 17
******************************************************************/
Program:
Step 2:
<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0</version>
</dependency>
</dependencies>

Step 3:
[Link]
package [Link];
public interface Vehicle {
void drive_process();
}

Step 4:
[Link] file
package [Link];
import [Link].*;
import [Link];
@Component
public class Engine {
public static List<String> engines=new ArrayList<String>();
static {
[Link]("Fan");
[Link]("Fuel Tank");
[Link]("Sensor");
[Link]("Water plump");
}

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

Step 5:
[Link] File
import [Link];
@Component
public class Car implements Vehicle {
@Autowired
private Engine engine;

public List<String>view_engine() {
return [Link]();
}
public void drive_process() {
[Link]("Driving.....");
}
}

Step 6:
[Link] file
package [Link];
import [Link];
import [Link];
package [Link];
import [Link];
import [Link];
@Configuration
@ComponentScan("[Link]")
public class AppConfig {
//Do your startup Configurations
}
Step 7:
[Link] File
package [Link];
import [Link];
import [Link];

public class App

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

Car c1=[Link]([Link]);
[Link](c1.view_engine());
}
}

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

PROGRAM:

Step 2:
<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0</version>
</dependency>
</dependencies>
Step 3:
[Link] File
package [Link];
public class Employee {

private int id;

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

Step 4:
[Link] File
package [Link];

public class Address {

private String state;
private String city;

public String getState() {

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

Step 5:
[Link] File
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
<bean id="employee" class="[Link]">
<property name="id" value="101"></property>
<property name="name" value="Lakshita"></property>
<property name="address">
<bean class="[Link]">
<property name="state" value="Chennai"></property>
<property name="city" value="TamilNadu"></property>
</bean>
</property>
</bean>
</beans>
Step 6:
[Link] File
package [Link];
import [Link];
import [Link];
public class App
{
 public static void main( String[] args )
{
ApplicationContext context = new
ClassPathXmlApplicationContext("[Link]");

Employee emp=(Employee)[Link]("employee");
[Link](emp);
}
}

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

Program:
Step 1: Create a model for the registration form (`[Link]`):
public class RegistrationForm {
private String name;
private String email;
private String password;
// Getters and setters
}
Step 2: Create a controller (`[Link]`):
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Controller
public class RegistrationController {
@GetMapping("/register")
public String showRegistrationForm(Model model) {
[Link]("registrationForm", new RegistrationForm());
return "registration-form";
}
@PostMapping("/register")
public String processRegistrationForm(
@Valid @ModelAttribute("registrationForm") RegistrationForm form,
BindingResultbindingResult) {
if ([Link]()) {
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 (`[Link]`):

<%@ 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 (`[Link]`):
<%@ 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 `[Link]` 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 [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@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 [Link]() {
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 `[Link]` package.
For example, to require that the `name` field is not empty, use the `@NotBlank`
annotation:

import [Link];
// ...

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 [Link];
import [Link];
import
[Link];
@Configuration
public class WebConfig {
// Other configuration

@Bean
public MessageSourcemessageSource() {
ReloadableResourceBundleMessageSourcemessageSource = new
ReloadableResourceBundleMessageSource();
[Link]("classpath:messages");
[Link]("UTF-8");
return messageSource;
}
}
Step 5.6: Create Validation Error Messages:
Define validation error messages in properties files (e.g., `[Link]`).
These messages should correspond to the
validation annotations and
can be localized for different languages.
Example `[Link]`:
[Link]=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 (`[Link]`):
<mvc:annotation-driven />
<bean id="messageSource"
class="[Link]">
<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 `[Link]

/*****************************************************************
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 = [Link]();
[Link]("products", products);
return "product-list";
}
}
Step 5: Create the View
Create a JSP view (e.g., `[Link]`) 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>${[Link]}</td>
<td>${[Link]}</td>
<td>${[Link]}</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., `[Link]`,
`servlet-
[Link]`, and `[Link]`).
Step 7: Run the Application
Run your Spring application and access the product list at
`[Link]

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
{
[Link](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/[Link]`, `admin/[Link]`) 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.