JDBCTemplate set verschachtelte POJO mit BeanPropertyRowMapper

Frühjahr wurde eine neue AutoGrowNestedPaths Eigenschaft in der BeanMapper - Schnittstelle.

Solange die SQL-Abfrage formatiert die Spalte-Namen mit ein . Trennzeichen (wie vor), dann wird die Zeile mapper wird automatisch target inneren Objekte.

Mit diesem, ich habe eine neue generische Zeile mapper wie folgt:

ABFRAGE:

SELECT title AS "message.title", question AS "message.question", user_name AS "user.user_name", display_name AS "user.display_name" FROM message, user WHERE user_id = message_id

ZEILE MAPPER:

package nested_row_mapper;

import org.springframework.beans.*;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.JdbcUtils;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;

public class NestedRowMapper<T> implements RowMapper<T> {

  private Class<T> mappedClass;

  public NestedRowMapper(Class<T> mappedClass) {
    this.mappedClass = mappedClass;
  }

  @Override
  public T mapRow(ResultSet rs, int rowNum) throws SQLException {

    T mappedObject = BeanUtils.instantiate(this.mappedClass);
    BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(mappedObject);

    bw.setAutoGrowNestedPaths(true);

    ResultSetMetaData meta_data = rs.getMetaData();
    int columnCount = meta_data.getColumnCount();

    for (int index = 1; index <= columnCount; index++) {

      try {

        String column = JdbcUtils.lookupColumnName(meta_data, index);
        Object value = JdbcUtils.getResultSetValue(rs, index, Class.forName(meta_data.getColumnClassName(index)));

        bw.setPropertyValue(column, value);

      } catch (TypeMismatchException | NotWritablePropertyException | ClassNotFoundException e) {
         //Ignore
      }
    }

    return mappedObject;
  }
}

InformationsquelleAutor nclord

Update: 10/4/2015. Ich normalerweise nicht tun diese rowmapping mehr. Sie erreichen die selektive JSON-Darstellung viel mehr aus über Anmerkungen. Sehen Sie diese gist.

Ich verbrachte den besseren Teil von einem ganzen Tag versuchen, um dies herauszufinden, für meinen Fall der 3-Schicht-verschachtelte Objekte und schließlich nur genagelt. Hier ist meine situation:

Konten (d.h. Benutzer) --1tomany--> Rollen --1tomany--> Ansichten (Benutzer sehen darf)

(Diese POJO-Klassen eingefügt ganz unten.)

Und ich wollte den controller zurückgeben, ein Objekt wie dieses:

[ {
  "id" : 3,
  "email" : "[email protected]",
  "password" : "sdclpass",
  "org" : "Super-duper Candy Lab",
  "role" : {
    "id" : 2,
    "name" : "ADMIN",
    "views" : [ "viewPublicReports", "viewAllOrders", "viewProducts", "orderProducts", "viewOfferings", "viewMyData", "viewAllData", "home", "viewMyOrders", "manageUsers" ]
  }
}, {
  "id" : 5,
  "email" : "[email protected]",
  "password" : "stereopass",
  "org" : "Stereolab",
  "role" : {
    "id" : 1,
    "name" : "USER",
    "views" : [ "viewPublicReports", "viewProducts", "orderProducts", "viewOfferings", "viewMyData", "home", "viewMyOrders" ]
  }
}, {
  "id" : 6,
  "email" : "[email protected]",
  "password" : "ukmedpass",
  "org" : "University of Kentucky College of Medicine",
  "role" : {
    "id" : 2,
    "name" : "ADMIN",
    "views" : [ "viewPublicReports", "viewAllOrders", "viewProducts", "orderProducts", "viewOfferings", "viewMyData", "viewAllData", "home", "viewMyOrders", "manageUsers" ]
  }
} ]

Ein wesentlicher Punkt ist, zu erkennen, dass der Frühling nicht nur alle tun dies automatisch für Sie. Wenn Sie Fragen Sie einfach, bis Sie wieder einen Account posten ohne die Arbeit von verschachtelten Objekten, Sie werden nur immer:

{
  "id" : 6,
  "email" : "[email protected]",
  "password" : "ukmedpass",
  "org" : "University of Kentucky College of Medicine",
  "role" : null
}

So, erste, erstellen Sie Ihre 3-Tabelle SQL-JOIN-Abfrage, und stellen Sie sicher, dass Sie immer alle Daten, die Sie benötigen. Hier ist meins, wie es scheint, auf mein Controller:

@PreAuthorize("hasAuthority('ROLE_ADMIN')")
@RequestMapping("/accounts")
public List<Account> getAllAccounts3() 
{
    List<Account> accounts = jdbcTemplate.query("SELECT Account.id, Account.password, Account.org, Account.email, Account.role_for_this_account, Role.id AS roleid, Role.name AS rolename, role_views.role_id, role_views.views FROM Account JOIN Role on Account.role_for_this_account=Role.id JOIN role_views on Role.id=role_views.role_id", new AccountExtractor() {});
    return accounts;
}

Beachten Sie, dass ich bin bei 3 Tabellen. Erstellen Sie nun eine RowSetExtractor Klasse zu setzen, die geschachtelte Objekte zusammen. Die oben genannten Beispiele zeigen, 2-Schicht-Schachteln... damit geht man einen Schritt weiter und hat 3 Ebenen. Beachten Sie, dass ich für die Pflege der second-layer-Objekt in einer Karte als gut.

public class AccountExtractor implements ResultSetExtractor<List<Account>>{

    @Override
    public List<Account> extractData(ResultSet rs) throws SQLException, DataAccessException {

        Map<Long, Account> accountmap = new HashMap<Long, Account>();
        Map<Long, Role> rolemap = new HashMap<Long, Role>();

        //loop through the JOINed resultset. If the account ID hasn't been seen before, create a new Account object. 
        //In either case, add the role to the account. Also maintain a map of Roles and add view (strings) to them when encountered.

        Set<String> views = null;
        while (rs.next()) 
        {
            Long id = rs.getLong("id");
            Account account = accountmap.get(id);
            if(account == null)
            {
                account = new Account();
                account.setId(id);
                account.setPassword(rs.getString("password"));
                account.setEmail(rs.getString("email"));
                account.setOrg(rs.getString("org"));
                accountmap.put(id, account);
            }

            Long roleid = rs.getLong("roleid");
            Role role = rolemap.get(roleid);
            if(role == null)
            {
                role = new Role();
                role.setId(rs.getLong("roleid"));
                role.setName(rs.getString("rolename"));
                views = new HashSet<String>();
                rolemap.put(roleid, role);
            }
            else
            {
                views = role.getViews();
                views.add(rs.getString("views"));
            }

            views.add(rs.getString("views"));
            role.setViews(views);
            account.setRole(role);
        }
        return new ArrayList<Account>(accountmap.values());
    }
}

Und dieser gibt die gewünschte Ausgabe. POJOs unten für Referenz. Hinweis: der @ElementCollection Einstellen der Ansichten, die in der Rolle Klasse. Dies ist, was erzeugt automatisch die role_views Tabelle verwiesen, in der SQL-Abfrage. Wissend, dass die Tabelle vorhanden ist, seinen Namen und seinen Feldnamen ist entscheidend, immer die SQL-Abfrage Recht. Es fühlt sich falsch an, zu haben, zu wissen, dass... es scheint, wie dieses sollte mehr automagic -- ist das nicht, was Frühling ist?... aber ich konnte nicht herausfinden, einen besseren Weg. Sie zu tun haben, die Arbeit manuell in diesem Fall, so weit ich erzählen kann.

@Entity
public class Account implements Serializable {
        private static final long serialVersionUID = 1L;

        @Id 
        @GeneratedValue(strategy=GenerationType.AUTO)
        private long id;
        @Column(unique=true, nullable=false)
        private String email;
        @Column(nullable = false) 
        private String password;
        @Column(nullable = false) 
        private String org;
        private String phone;

        @ManyToOne(fetch = FetchType.EAGER, optional = false)
        @JoinColumn(name = "roleForThisAccount") //@JoinColumn means this side is the *owner* of the relationship. In general, the "many" side should be the owner, or so I read.
        private Role role;

        public Account() {}

        public Account(String email, String password, Role role, String org) 
        {
            this.email = email;
            this.password = password;
            this.org = org;
            this.role = role;
        }
        //getters and setters omitted

    }

   @Entity
   public class Role implements Serializable {

        private static final long serialVersionUID = 1L;

        @Id 
        @GeneratedValue(strategy=GenerationType.AUTO)   
        private long id; //required

        @Column(nullable = false) 
        @Pattern(regexp="(ADMIN|USER)")
        private String name; //required

        @Column
        @ElementCollection(targetClass=String.class)
        private Set<String> views;

        @OneToMany(mappedBy="role")
        private List<Account> accountsWithThisRole;

        public Role() {}

        //constructor with required fields
        public Role(String name)
        {
            this.name = name;
            views = new HashSet<String>();
            //both USER and ADMIN
            views.add("home");
            views.add("viewOfferings");
            views.add("viewPublicReports");
            views.add("viewProducts");
            views.add("orderProducts");
            views.add("viewMyOrders");
            views.add("viewMyData");
            //ADMIN ONLY
            if(name.equals("ADMIN"))
            {
                views.add("viewAllOrders");
                views.add("viewAllData");
                views.add("manageUsers");
            }
        }

        public long getId() { return this.id;}
        public void setId(long id) { this.id = id; };

        public String getName() { return this.name; }
        public void setName(String name) { this.name = name; }

        public Set<String> getViews() { return this.views; }
        public void setViews(Set<String> views) { this.views = views; };
    }

InformationsquelleAutor fivedogit