Persistindo beans com o MentaBeans

Considerando o seguinte modelo:

Beans:

public class Car {
    
    private int id;
    private String name;
    private Date year;
    
    private int engineId; // o mentabean pode injetar diretamente o id aqui.
    private Engine engine = null;
    
    // requerido
    public Car() {
        
    }
    
    public Car(int id) {
        this.id = id;
    }
    
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    
    public Engine getEngine() {
        return engine;
    }
    
    // outros getters e setter aqui
}

public class Engine {
    
    private int id;
    private String name;
    private int type;
    
    private List<Part> parts = null;
    
    // requerido
    public Engine() {
        
    }
    
    public Engine(int id) {
        this.id = id;
    }
    
    public void setParts(List<Part> parts) {
        this.parts = parts;
    }
    
    public List<Part> getParts() {
        return parts;
    }
    
    // outros getters e setter aqui
}

public class Part {
    
    private int id;
    private String name;
    
    // requerido
    public Part() {
        
    }
    
    public Part(int id) {
        this.id = id;
    }
    
    // outros getters e setter aqui
}

No ApplicationManager:

public class ApplicationManager extends org.mentawai.core.ApplicationManager {
    
    public void loadActions() {
        // suas actions vão aqui.
    }
    
    public void loadBeans() {
        
        // configure os atributos do bean
        
        BeanConfig car = bean(Car.class, "Cars")
                .pk("id", DBTypes.AUTOINCREMENT)
                .field("name", DBTypes.STRING)
                .field("year", DBTypes.DATE)
                .field("engineId", "engin_id", DBTypes.INTEGER);
                
        BeanConfig engine = bean(Engine.class, "Engines")
                .pk("id", DBTypes.AUTOINCREMENT, "engin_id" /* = FK */)
                .field("name", DBTypes.STRING)
                .field("type", "industryType", DBTypes.INTEGER);
                
        BeanConfig part = bean(Part.class, "Parts")
                .pk("id", DBTypes.AUTOINCREMENT, "part_id" /* = FK */)
                .field("name", DBTypes.STRING);
                
        // configure o relacionamentos entre os beans
        
        engine.join(Part.class, "EnginesParts"); // relacionamento um-para-muitos
        
    }

public void init(Context application) {

filter(new ConnectionFilter(connHandler));
        
        filter(new IoCFilter());
        ioc("session", MySQLBeanSession.class); // ou JdbcBeanSession apenas para ANSI SQL...

filter(new DIFilter()); 
        di("conn", Connection.class); // um JdbcBeanSession precisa de um Connection !!!!

}
}

Carregando os beans:

public class BeanActionExample extends BaseAction {
    
    public String execute() throws Exception {
        
        BeanSession session = (BeanSession) input.getValue("session"); // ioc vai funcionar aqui
        
        Car car = new Car(1); // car id = 1 (PK)
        
        boolean loaded = session.load(car);
        
        if (loaded) {
            
            System.out.println("Carro carregado: " + car.getName());
            
        } else {
            
            throw new ActionException("Impossível carregar o carro com o id = " + car.getId());
            
        }
        
        // vamos carregar o motor deste carro (relacionamento um-para-um)
        
        Engine engine = new Engine(car.getEngineId());
        
        loaded = session.load(engine);
        
        if (loaded) {
            
            car.setEngine(engine); // atribua o motor para este carro.
            
            System.out.println("Motor carregado: " + engine.getName());
            
        } else {
            
            throw new ActionException("Impossível carregar o motor com o id = " + engine.getId());
            
        }
        
        // Agora vamos carregar a lista de peças para o motor (relacionamento um-para-muitos)
        
        List<Parts> parts = session.loadJoin(engine, Peca.class);
        
        engine.setParts(parts); // atribua uma lista de peças para este motor
        
        System.out.println("Número de peças carregadas: " + parts.size());
        
        // você também pode carregar apenas os IDs
        
        List<Integer> ids = session.loadJoinIds(engine, Peca.class);
        
        // Você também pode contar os IDs
        
        int total = session.countJoin(engine, Peca.class);
        
        return SUCCESS;
    }
}

Inserindo beans:

// Se você está usando MySQL, e o id (PK) da classe Car estiver configurada como AUTOINCREMENT...
        
        Car car = new Car(); // ...não informe a chave (id)
        u.setName("Parati");
        u.setYear(DateFormat.parse("21/01/2005"));
        
        session.insert(car);
        
        System.out.println("Executada a inserção do carro com id: " + car.getId());
        
        // Se você está usando Oracle e o id (PK) da classe Car estiver configurada como SEQUENCE...
        // ...neste caso você deve criar uma sequence no seu BD com o nome seq_id_Cars (seq_COLUNA_DA_TABELA)
        
        Car car = new Car(); //  Não informe a chave (id)
        u.setName("Parati");
        u.setYear(DateFormat.parse("21/01/2005"));
        
        session.insert(car);
        
        System.out.println("Executada a inserção do carro com id: " + car.getId());
        
        // Se você quiser fazer as coisas independente de banco de dados, então você vai precisar pegar um id único de algum lugar.
        // Neste caso, você pode configurar o campo como um INTEGER normal, sem AUTOINCREMENT nem SEQUENCE.
        
        int id = getUniqueId();
        
        Car car = new Car(id); // Informe a chave (id) do carro
        u.setName("Parati");
        u.setYear(DateFormat.parse("21/01/2005"));
        
        session.insert(car);
        
        System.out.println("Executada a inserção do carro com id: " + id);

Adicionando beans com relacionamentos (um-para-um):

Adicionando beans com relacionamentos (um-para-muitos):

Removendo beans com relacionamentos (um-para-muitos):

Atualizando um bean:

Deletando um bean:

Carregando listas: