Scribd
Upload
11 views

UserManagementLab

This document outlines a lab for building a User Management System using a database. It includes steps for setting up a database, creating a DBAccess class for managing connections, adding user insertion and email validation logic, refactoring the Users class, and integrating the system with a forms application for user registration and login. The lab concludes with testing the complete application to ensure all functionalities work as expected.

Uploaded by

Judith Nelson
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
11 views

UserManagementLab

This document outlines a lab for building a User Management System using a database. It includes steps for setting up a database, creating a DBAccess class for managing connections, adding user insertion and email validation logic, refactoring the Users class, and integrating the system with a forms application for user registration and login. The lab concludes with testing the complete application to ensure all functionalities work as expected.

Uploaded by

Judith Nelson
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

Lab: Building a User Management System with a Database

Objective
By the end of this lab, you will:
1. Create a `DBAccess` class to manage database connections and operations.
2. Refactor the `Users` class to use `DBAccess` for database interactions.
3. Integrate the database with a forms application for user registration and login.

Step 1: Set Up the Database


1. Open your H2 database console or use the provided configuration.
2. Create a `Users` table using the following SQL:

CREATE TABLE IF NOT EXISTS Users (


id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50),
email VARCHAR(100) NOT NULL UNIQUE,
password VARCHAR(255) NOT NULL
);

3. Record your database URL, username, and password. These will be used to connect your
application to the database.

Step 2: Create the DBAccess Class


**Goal**: Create a class to manage database connections and basic operations.

1. Define a `DBAccess` class with:


- A private static instance (`DBAccess`): ensures only one database connection is created.
- A private constructor: sets up the connection to the database.
- A `getInstance()` method: returns the single instance of `DBAccess`.

public class DBAccess {


private static DBAccess instance;
private Connection connection;

private DBAccess() {
String jdbcURL = "jdbc:h2:~/mydatabase";
String username = "sa";
String password = "";
try {
connection = DriverManager.getConnection(jdbcURL,
username, password);
System.out.println("Database connection
established.");
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException("Failed to connect to the
database");
}
}

public static DBAccess getInstance() {


if (instance == null) {
instance = new DBAccess();
}
return instance;
}
public Connection getConnection() {
return connection;
}
}

2. Test your `DBAccess` class by calling `DBAccess.getInstance()` in a simple test.

Step 3: Add User Insertion Logic


**Goal**: Add a method to insert new users into the database.

1. Add a `public boolean insertUser(User user)` method to `DBAccess`.


2. Use a `PreparedStatement` to insert values into the `Users` table. The SQL should look like
this:

INSERT INTO Users (username, email, password) VALUES (?, ?, ?);

3. Set the placeholders (`?`) using values from the `User` object:
- `user.getFirstName()` + " " + `user.getLastName()` for the username.
- `user.getEmail()` for the email.
- `user.getPassword()` for the password.

4. Handle exceptions to check for duplicate email errors (unique constraint violations).

Step 4: Add Email Validation


**Goal**: Ensure no two users have the same email.
1. Add a `public boolean isEmailUnique(String email)` method in `DBAccess`.
2. Write a query to check if an email exists in the database:

SELECT COUNT(*) FROM Users WHERE email = ?;


3. Use a `PreparedStatement` to set the `?` placeholder to the email address provided. Then
execute the query and get the result using a `ResultSet`.

4. Check if the result is `0` (email is unique) or greater than `0` (email already exists). Return
`true` for unique emails and `false` otherwise.

**Hint**: Here's how you can use `ResultSet` to get the count:

ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
int count = rs.getInt(1);
return count == 0;
}

Step 5: Refactor the Users Class


**Goal**: Use `DBAccess` to delegate database tasks and keep validation logic in `Users`.
1. Update the `addUser` method to:
- Call `DBAccess.isEmailUnique()` to check if the email is already in use.
- Call `DBAccess.insertUser()` to add the user to the database if validation passes.

2. Ensure that `Users` still handles password validation (e.g., checking for strength).

public boolean addUser(User user) {


DBAccess dbAccess = DBAccess.getInstance();
if (!dbAccess.isEmailUnique(user.getEmail())) {
System.out.println("Email is already in use.");
return false;
}
if (!isPasswordStrong(user.getPassword())) {
System.out.println("Password is not strong enough.");
return false;
}
return dbAccess.insertUser(user);
}

private boolean isPasswordStrong(String password) {


return password.length() >= 8 && password.matches(".*[A-
Z].*") && password.matches(".*[0-9].*");
}

3. Test this method by creating a `Users` object and calling `addUser` with various `User` objects.
Step 6: Integrate with the Forms Application
**Goal**: Connect the database logic with your forms for user registration and login.
1. In your registration form:
- Collect user input for first name, last name, email, and password.
- Create a `User` object with the input data.
- Call the `addUser()` method from the `Users` class to register the user.

2. In your login form:


- Collect user input for email and password.
- Add a `validateLogin(String email, String password)` method to `DBAccess`.
- Use this method to verify the user's credentials.

public boolean validateLogin(String email, String password) {


String sql = "SELECT COUNT(*) FROM Users WHERE email = ? AND
password = ?";
try (PreparedStatement pstmt =
connection.prepareStatement(sql)) {
pstmt.setString(1, email);
pstmt.setString(2, password);
ResultSet rs = pstmt.executeQuery();
return rs.next() && rs.getInt(1) > 0;
} catch (SQLException e) {
e.printStackTrace();
}
return false;
}

3. Show messages on the form based on success or failure (e.g., 'Registration successful!' or
'Invalid email or password').

Step 7: Test the Complete Application


**Goal**: Test your forms with different scenarios to ensure everything works as expected.
1. Test registration with:
- A valid user.
- A user with a duplicate email.
- A user with a weak password.

2. Test login with:


- Correct credentials.
- Incorrect email or password.

3. Verify that the database updates correctly after each test.


- Use the H2 console or a database viewer to check the `Users` table.
Step 7: Test the Complete Application (with Hints)
**Goal**: Test your forms with different scenarios to ensure everything works as expected.

1. Test registration with the following scenarios:


- A valid user: Ensure the user is added to the database.
- A duplicate email: Try registering the same email again and confirm that the application
prevents it.
- A weak password: Test with passwords that fail your strength checks.

**Hint for Testing Registration**:


- Use your form's input fields to enter details and observe the messages displayed (e.g., 'Email
already exists').
- Open the H2 database console and run a query to verify the data:

You might also like