Nullpointer metody

Odpowiedz Nowy wątek
2019-08-12 21:35
0

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();
edytowany 1x, ostatnio: kq, 2019-08-12 22:27

Pozostało 580 znaków

2019-08-14 09:03
0

Niby czemu przeciążona

Pozostało 580 znaków

2019-08-14 09:56
0

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.

edytowany 1x, ostatnio: catom, 2019-08-14 09:57

Pozostało 580 znaków

wczoraj, 21:25
0
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:

// 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

Której wersji Javy używasz? Kod pisałem akurat tylko w edytorze tekstowym na forum. Jeśli używasz wersji starszej niż JDK 9, to zrób po prostu Arrays.asList(), jak z resztą napisali koledzy w poniższych postach. - catom dziś, 09:44

Pozostało 580 znaków

wczoraj, 21:30
0

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


Masz problem? Pisz na forum, nie do mnie. Nie masz problemów? Kup komputer...

Pozostało 580 znaków

wczoraj, 21:39
0

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

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0