Diesmal habe ich eine Implementierung ausprobiert, die MyBatis Dynamic SQL verwendet, um SQL auszugeben und Daten abzurufen!
Ich werde es für geschäftliche Zwecke verwenden, also werde ich es als Memorandum belassen. Das Implementierungsformat ähnelt dem S2JDBC von Seasar2, und SQL wird durch Ausführen mehrerer Methodenketten erstellt.
Ich habe so einen einfachen Tisch vorbereitet. Registrieren Sie mehrere Daten in Texto.
CREATE TABLE "MEMBER" (
"ID" NUMBER(8,0)
, "BLOOD" VARCHAR2(20 BYTE)
, "NAME" VARCHAR2(20 BYTE)
, "CORP" VARCHAR2(20 BYTE)
);
Die Entität wird auch gemäß der Tabellenstruktur erstellt.
public class Member {
private Integer id;
private String name;
private String corp;
private String blood;
//Getter / Setter weggelassen
}
Erstellen Sie die Mapper-Schnittstelle wie folgt. Dieses Mal wird davon ausgegangen, dass mehrere Daten an List zurückgegeben werden.
public interface MemberMapper {
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@Results(id="memberResult", value={
@Result(column="ID", property="id"),
@Result(column="NAME", property="name"),
@Result(column="CORP", property="corp"),
@Result(column="BLOOD", property="blood"),
})
List<Member> selectMany(SelectStatementProvider selectStatement);
}
Erstellen Sie eine Supportklasse für die Arbeit mit MyBatis Dynamic SQL. Es wird verwendet, wenn die zu erfassende Spalte oder die WHERE-Klausel angegeben wird.
public final class MemberDynamicSqlSupport {
public static final Member Member = new Member();
public static final SqlColumn <Integer> id = Member.id;
public static final SqlColumn <String> name = Member.name;
public static final SqlColumn <String> corp = Member.corp;
public static final SqlColumn <String> blood = Member.blood;
public static final class Member extends SqlTable {
public final SqlColumn <Integer> id = column("ID", JDBCType.INTEGER);
public final SqlColumn <String> name = column("NAME", JDBCType.VARCHAR);
public final SqlColumn <String> corp = column("CORP", JDBCType.VARCHAR);
public final SqlColumn <String> blood = column("BLOOD", JDBCType.VARCHAR);
public Member() {
super("Member");
}
}
}
Implementieren wir eine Klasse, die tatsächlich SQL mit der oben erstellten Klasse ausgibt. Dieses Mal werde ich den Testcode mit junit implementieren.
import static jp.co.stylez.support.MemberDynamicSqlSupport.*;
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
import static org.mybatis.dynamic.sql.SqlBuilder.isLessThan;
import static org.mybatis.dynamic.sql.SqlBuilder.select;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = MybatisConfig.class)
public class Main {
@Autowired
ApplicationContext context;
@Test
public void test() {
MemberMapper mapper = context.getBean(MemberMapper.class);
SelectStatementProvider selectStatement = select(Member.allColumns()).from(Member).where(id, isLessThan(10))
.and(corp, isEqualTo("stylez")).orderBy(id).build().render(RenderingStrategies.MYBATIS3);
List<Member> members = mapper.selectMany(selectStatement);
for (Member member : members) {
System.out.println("********************");
System.out.println("id：" + member.getId());
System.out.println("name：" + member.getName());
System.out.println("corp：" + member.getCorp());
System.out.println("blood：" + member.getBlood());
System.out.println("********************");
}
}
}
Implementieren Sie die Config-Klasse separat und legen Sie die DataSource- und MapperScan-Ziele fest. Es kann im XML-Format eingestellt werden, diesmal jedoch in Java. (Ich werde die Erklärung bezüglich der Einstellung weglassen)
Der bei MapperScan registrierte Mapper wird entfernt und die SQL wird tatsächlich ausgeführt.
Das Ausführungsergebnis ist wie folgt.
********************
id：1
name：hogehoge
corp：stylez
blood：B
********************
********************
id：2
name：test.taro
corp：stylez
blood：O
********************
********************
id：3
name：hiroya.endo
corp：stylez
blood：A
********************
Es wurde bestätigt, dass mehrere Daten mit den angegebenen Bedingungen erfasst werden konnten!
Ich hatte das Gefühl, dass es möglich ist, es sehr flexibel umzusetzen, hauptsächlich in Bezug auf die Bedingungsspezifikation der WHERE-Klausel. Der Code war sehr gut lesbar und leicht zu beschichten, so dass ich den Eindruck hatte, dass er einfach zu verwenden war.
Ich denke, das ist auch eine der Attraktionen, weil es Tabellenverknüpfungen und Unterabfragen verarbeiten kann. Es ist auch möglich, es ordnungsgemäß mit SQL zu verwenden, das Mapper.xml verwendet, sodass ich denke, dass Sie die Konfiguration nach Bedarf verwalten können.
Ich hoffe, es wird eine gute Referenz für diejenigen sein, die es von nun an verwenden werden!
https://github.com/mybatis/mybatis-dynamic-sql
https://mybatis.org/mybatis-dynamic-sql/docs/conditions.html