Nullpointer metody

Wywala mi tutaj Nullpointera dlaczego ? CHodzi mi o metody addEmployee

package PAkietSQL;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import domain.Employee;

public class Main {
private static EntityManager entityManager;
private static EntityManagerFactory entityManagerFactory;

	public static void main(String[] args) {
		EntityManagerFactory entityManagerFactory =Persistence.createEntityManagerFactory("myDataBase") ;
EntityManager entityManager = entityManagerFactory.createEntityManager();

addEmployees();


entityManager.close();
entityManagerFactory.close();
	}

private static void addEmployees() {
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	addEmployee("Maciek","ss", 2000);
	
}

private static void addEmployee(String firstName,String lastName, double salary)
{
	Employee employee=new Employee();
	employee.setFirstName(firstName);
	employee.setLastName(lastName);
	employee.setSalary(salary);
	
	entityManager.getTransaction().begin();
	entityManager.persist(employee);
entityManager.getTransaction().commit();

Co jest tutaj nullem? entityManager?

W metodzie main tworzysz nową zmienną lokalną entityManager zamiast przypisać to do pola klasy.

radek1234 napisał(a):

W metodzie main tworzysz nową zmienną lokalną entityManager zamiast przypisać to do pola klasy.

ale dalej jest null

Exception in thread "main" java.lang.NullPointerException
at PAkietSQL.Main.addEmployee(Main.java:46)
at PAkietSQL.Main.addEmployees(Main.java:25)
at PAkietSQL.Main.main(Main.java:17)

MrZiomenOmen napisał(a):

radek1234 napisał(a):

W metodzie main tworzysz nową zmienną lokalną entityManager zamiast przypisać to do pola klasy.

ale dalej jest null

Exception in thread "main" java.lang.NullPointerException
at PAkietSQL.Main.addEmployee(Main.java:46)
at PAkietSQL.Main.addEmployees(Main.java:25)
at PAkietSQL.Main.main(Main.java:17)

public static void main(String[] args) {

	EntityManagerFactory entityManagerFactory =Persistence.createEntityManagerFactory("myDataBase") ;

entityManagerFactory.createEntityManager();

addEmployees();

entityManager.close();
entityManagerFactory.close();

Teraz w ogóle nie przypisujesz wartości z entityManagerFactory.createEntityManager();
powinno być:
entityManager = entityManagerFactory.createEntityManager();

Spróbuj może używać obiektów i nie operuj na zmiennych i metodach statycznych.
Stwórz sobie np. klasę EmployeeRepository, która będzie miała metodę addEmployee().
Niech klasa EmployeeRepository ma pole EntityManager (najlepiej z modyfikatorem final) i wstrzykiwanie tej zależności odbywa się przez konstruktor. Wtedy nie dość, że kod będzie ładniej wyglądał, to jeszcze pomoże Ci to w uniknięciu takich dziwnych problemów.

Btw. to już bodajże 3. Twój post*, w którym masz problem z przypisywaniem i zasięgiem zmiennych. Może zerknij sobie na początek, na ten skrótowy wpis Java Variable Scope.

* Żeby nie być gołosłownym:

• TRANSFER Bank
• Value of local variable is not used =HELP

catom napisał(a):

Spróbuj może używać obiektów i nie operuj na zmiennych i metodach statycznych.
Stwórz sobie np. klasę EmployeeRepository, która będzie miała metodę addEmployee().
Niech klasa EmployeeRepository ma pole EntityManager (najlepiej z modyfikatorem final) i wstrzykiwanie tej zależności odbywa się przez konstruktor. Wtedy nie dość, że kod będzie ładniej wyglądał, to jeszcze pomoże Ci to w uniknięciu takich dziwnych problemów.

Btw. to już bodajże 3. Twój post*, w którym masz problem z przypisywaniem i zasięgiem zmiennych. Może zerknij sobie na początek, na ten skrótowy wpis Java Variable Scope.

---

* Żeby nie być gołosłownym:

• TRANSFER Bank
• Value of local variable is not used =HELP

Nie rozmumiem tego wstrzykiwania przez konstruktor znalazłem coś takiego ale po co mi to jest właściwie
public class Shop {

private ShoppingCard shoppingCard;

@Autowired
public Shop(ShoppingCard shoppingCard) {
    this.shoppingCard = shoppingCard;
}

public void purchase() {
    shoppingCard.addProductToShoppingCard(new Product(1, "Milk"));
    shoppingCard.addProductToShoppingCard(new Product(2, "Tea"));
    shoppingCard.addProductToShoppingCard(new Product(3, "Bread"));
}

Rozumiem jak mam konstruktoe Employee(name,age) itd to że moge sobie zrobić tak Employee("Jaś",2) ale co mi daje np Employee(Card card) ?

Poprzez wstrzykiwanie przez konstruktor odnoszę się do jednej z technik programowania obiektowego - Dependency Injection - niekoniecznie z wykorzystaniem kontenerów i Inversion of Control.

Przykładowe źródła:

• Dependency Injection in Java.
• Wiki - Dependency Injection - Examples

W Twoim przypadku, byłoby to:

public class EmployeeRepository {
  
  private final EntityManager entityManager;
  
  public EmployeeRepository(EntityManager entityManager) { // o tu jest wstrzykiwanie zależności przez konstruktor - EntityManager jest Twoją zależnością
    this.entityManager = entityManager;
  }
  
  public void addEmployee(Employee employee) {
    // tutaj dodanie employee do bazy poprzez wykorzystanie wstrzykniętego wcześniej EntityManagera
  }
}

catom napisał(a):

Poprzez wstrzykiwanie przez konstruktor odnoszę się do jednej z technik programowania obiektowego - Dependency Injection - niekoniecznie z wykorzystaniem kontenerów i Inversion of Control.

Przykładowe źródła:

• Dependency Injection in Java.
• Wiki - Dependency Injection - Examples

W Twoim przypadku, byłoby to:

Kopiuj

public class EmployeeRepository {
  
  private final EntityManager entityManager;
  
  public EmployeeRepository(EntityManager entityManager) { // o tu jest wstrzykiwanie zależności przez konstruktor - EntityManager jest Twoją zależnością

no dobra ale czym się to różni ? i po co mi to jest w konstruktorze w ogóle jak mam pole ?

this.entityManager = entityManager;

}

public void addEmployee(Employee employee) {
// tutaj dodanie employee do bazy poprzez wykorzystanie wstrzykniętego wcześniej EntityManagera
}
}

Kopiuj

catom napisał(a):

Poprzez wstrzykiwanie przez konstruktor odnoszę się do jednej z technik programowania obiektowego - Dependency Injection - niekoniecznie z wykorzystaniem kontenerów i Inversion of Control.

Przykładowe źródła:

• Dependency Injection in Java.
• Wiki - Dependency Injection - Examples

W Twoim przypadku, byłoby to:

Kopiuj

public class EmployeeRepository {
  
  private final EntityManager entityManager;
  
  public EmployeeRepository(EntityManager entityManager) { // o tu jest wstrzykiwanie zależności przez konstruktor - EntityManager jest Twoją zależnością
    this.entityManager = entityManager;
  }
  
  public void addEmployee(Employee employee) {
    // tutaj dodanie employee do bazy poprzez wykorzystanie wstrzykniętego wcześniej EntityManagera
  }
}

Rozumiem że ta metoda jest przeciążona ?

public void addEmployee(Employee employee) {

// tutaj dodanie employee do bazy poprzez wykorzystanie wstrzykniętego wcześniej EntityManagera

}

Niby czemu przeciążona

no dobra ale czym się to różni ? i po co mi to jest w konstruktorze w ogóle jak mam pole ?

W konstruktorze jest Ci to po to, żeby zależność przypisać podczas tworzenia obiektu. Samo Dependency Injection przyda Ci się np. w sytuacji, gdy potrzebujesz zmienić implementację swojej zależności.
Co do samych zalet (i wad) DI - znajdziesz je choćby w artykule do Wikipedii, który wcześniej podlinkowałem.

Oczywiście, że masz pole i obiekt przypisany do tego pola jest Twoją zależnością. Ale jakoś musisz to pole przypisać, żeby mieć referencję do instancji tej zależności. Gdybyś przypisywał to pole w konstruktorze, wówczas użycie Twojego obiektu z tym polem wymuszałoby na Tobie przekazanie od razu tej zależności i nie miałbyś problemu, że gdzieś w kodzie tworzysz sobie obiekt typu Twojej zależności, ale zapomniałeś go przypisać do tego pola.
Dokładnie to zrobiłeś w swoim kodzie z 1. postu.

Chodzi o takie wymuszenie:

// Repozytorium, jak wcześniej
public class EmployeeRepository {

  private final EntityManager entityManager;

  public EmployeeRepository(EntityManager entityManager) {
    this.entityManager = entityManager;
  }

  public void addEmployee(Employee employee) {
    // tutaj dodanie employee do bazy poprzez wykorzystanie wstrzykniętego wcześniej EntityManagera
  }
}

// i przykład użycia
public class Main {
  public static void main(String... args) {
    final EntityManager entityManager = Main.createEntityManager();
    final EmployeeRepository employeeRepostiory = new EmployeeRepository(entityManager); // tu jest to wymuszenie - bez przekazania EntityManager 
    // do konstruktora nie możesz utworzyć obiektu EmployeeRepository
    // dzięki temu, nigdy nie utworzysz EmployeeRepository, które nie będzie miało przypisanego pola "entityManager"
    
    // i tu odrobinę zmodyfikowany Twój dotychczasowy kod
   
    // utworzenie obiektów Employee do zapisania
    final List<Employee> employees = createEmployees();
    // i dla każdego z utworzonych Employee wołamy employeeRepository.addEmployee()
    // 1. z życiem metody Collection#forEach i method reference
    employees.forEach(employeeRepository::addEmployee);
    // 2. klasycznie, z for-each
    for(Employee employee : employees) {
      employeeRepository.addEmployee(employee);
    }
  }
  
  private static EntityManager createEntityManager() {
    EntityManagerFactory entityManagerFactory =Persistence.createEntityManagerFactory("myDataBase") ;
    return entityManagerFactory.createEntityManager();
  }

  private static List<Employee> createEmployees() {
    return List.of(
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000)
    );
  }
  
  private static Employee createEmployee(String firstName, String lastName, long salary) {
    Employee employee=new Employee();
    employee.setFirstName(firstName);
    employee.setLastName(lastName);
    employee.setSalary(salary);
    return employee;
  }
}

Powyższe rozwiązanie mogłoby być jeszcze ładniejsze stosując choćby Single Responsibility itd., ale nie o tym teraz rozmawiamy, więc starałem się zachować zgodność z Twoim dotychczasowym kodem.

Rozumiem że ta metoda jest przeciążona ?

Nic tu nie jest przeciążone. To jest po prostu przykład metody, która mogłaby zapisywać Employee.

catom napisał(a):

no dobra ale czym się to różni ? i po co mi to jest w konstruktorze w ogóle jak mam pole ?

W konstruktorze jest Ci to po to, żeby zależność przypisać podczas tworzenia obiektu. Samo Dependency Injection przyda Ci się np. w sytuacji, gdy potrzebujesz zmienić implementację swojej zależności.
Co do samych zalet (i wad) DI - znajdziesz je choćby w artykule do Wikipedii, który wcześniej podlinkowałem.

Oczywiście, że masz pole i obiekt przypisany do tego pola jest Twoją zależnością. Ale jakoś musisz to pole przypisać, żeby mieć referencję do instancji tej zależności. Gdybyś przypisywał to pole w konstruktorze, wówczas użycie Twojego obiektu z tym polem wymuszałoby na Tobie przekazanie od razu tej zależności i nie miałbyś problemu, że gdzieś w kodzie tworzysz sobie obiekt typu Twojej zależności, ale zapomniałeś go przypisać do tego pola.
Dokładnie to zrobiłeś w swoim kodzie z 1. postu.

Chodzi o takie wymuszenie:

Kopiuj

// Repozytorium, jak wcześniej
public class EmployeeRepository {

  private final EntityManager entityManager;

  public EmployeeRepository(EntityManager entityManager) {
    this.entityManager = entityManager;
  }

  public void addEmployee(Employee employee) {
    // tutaj dodanie employee do bazy poprzez wykorzystanie wstrzykniętego wcześniej EntityManagera
  }
}

// i przykład użycia
public class Main {
  public static void main(String... args) {
    final EntityManager entityManager = Main.createEntityManager();
    final EmployeeRepository employeeRepostiory = new EmployeeRepository(entityManager); // tu jest to wymuszenie - bez przekazania EntityManager 
    // do konstruktora nie możesz utworzyć obiektu EmployeeRepository
    // dzięki temu, nigdy nie utworzysz EmployeeRepository, które nie będzie miało przypisanego pola "entityManager"
    
    // i tu odrobinę zmodyfikowany Twój dotychczasowy kod
   
    // utworzenie obiektów Employee do zapisania
    final List<Employee> employees = createEmployees();
    // i dla każdego z utworzonych Employee wołamy employeeRepository.addEmployee()
    // 1. z życiem metody Collection#forEach i method reference
    employees.forEach(employeeRepository::addEmployee);
    // 2. klasycznie, z for-each
    for(Employee employee : employees) {
      employeeRepository.addEmployee(employee);
    }
  }
  
  private static EntityManager createEntityManager() {
    EntityManagerFactory entityManagerFactory =Persistence.createEntityManagerFactory("myDataBase") ;
    return entityManagerFactory.createEntityManager();
  }

  private static List<Employee> createEmployees() {
    return List.of(
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000),
      createEmployee("Maciek", "ss", 2000)
    );
  }
  
  private static Employee createEmployee(String firstName, String lastName, long salary) {
    Employee employee=new Employee();
    employee.setFirstName(firstName);
    employee.setLastName(lastName);
    employee.setSalary(salary);
    return employee;
  }
}

Powyższe rozwiązanie mogłoby być jeszcze ładniejsze stosując choćby Single Responsibility itd., ale nie o tym teraz rozmawiamy, więc starałem się zachować zgodność z Twoim dotychczasowym kodem.

Rozumiem że ta metoda jest przeciążona ?

Nic tu nie jest przeciążone. To jest po prostu przykład metody, która mogłaby zapisywać Employee.

Nie zwraca mi listy

The method of(Employee, Employee, Employee, Employee, Employee, Employee, Employee, Employee, Employee, Employee, Employee) is
undefined for the type List

podkreslone List.of

Może chciałeś jednak Arrays.asList(cośtam, cośtam, cośtam...)?

List.of(...) jest od jdk 9