**Mabatis -인터페이스를 이용한 사용
=>SQL Mapper(sql과 자바 코드의 분리) 방식의 데이터베이스 연동 프레임워크
=>사용법은 xml(예전 방식)을 이용하는 방법과 인터페이스 (최근의 방식)를 이용하는 방법
대부분 xml을 이용하는 방식이 초창기 방식이고 json이나 코드로 설정방식이 최근의 방식
1.spring프로젝트에서 MyBatis를 사용하기 위한 준비
=>spring-jdbc, mybatis, mybatis -spring 라이브러리
=>사용하고자 하는 데이터베이스 연동 라이브러리
=>데이터베이스 로그 기록 , lombok같은 라이브러리는 필수 사항이 아닙니다.
같이 사용을 많이 하기 때문에 필수 사항인것 처럼 여겨지는 것입니다.
2.인터페이스를 이용한 방식
=> 인터페이스를 생성
=>인터페이스 생성하고 데이터베이스 구동 메소드의 원형을 선언하고 위에 @하고자하는 sql이름(실제 sql)을 추가하해주면 됩니다.
=>spring bean configuration파일에 2개의 bean을 생성
sqlSessionFactoryBean을 생성하는데 여기에는 dataSource 프로퍼티에 사용할 데이터베이스의 DataSource를 설정
두번째는 MapperFacotryBean을 생성하는데 앞에서 만든 sqlSessionFactoryBean이 필요하고 또 하나는 인터페이스가 필요
인터페이스를 사용하는게 좀더 효율적이다 .별도 xml파일을 만들 필요가 없다.
=>다른 클래스에서 인터페이스를 주입받아서 사용하면 됩니다.
3.Goods테이블의 데이터의 crud작업을 mybatis 를 이용한 실습
1)데이터베이스 정보를 확인
-종류 : oracle
-url: ip주소 url주소:1521:xe(sid) 만약에 servicename을 이용하는 경우에는 /servicename
18c-> servivename으로 바꿨다.
-Username : user00
-password: user00
=>문서의 형태로 제공
popular확인하기
mariadb mybatis
db2는 ibm
odbc ->원두어용
시각화 microsoft bi 툴
db <-> odbc<-> ms bi tool
odbc-> 분석 을 하는데 c/c+
postgre sql->뮤료 개발자
sql server
sqlite->외부에서 접속이 안되서 embedded에서 사용한다. 프린트 등
apache hive : 하드배데이터를 에코시스템을 이용해서 일반 데이터베이스를 사용하게 끔 하는 것 java
mongoDB
SAP - HANADB 관계형데이터베이스
Oracle 대기업이 잴 많이 하는 것은 하나디비
공공기관 => tmax -> tibero
카카오는 mysql이다.
role 권한의 묶음
os authentication:운영체제로 서버나 cloud환경에서 하는 것
계정별로 권한이 정해진다.
mongodb는 아이디와 비밀번호 입력하지 않았다. ->os authentication
autocommit->하지 말아야 한다.
백업은 수시로 하기
2)프로젝트 생성
=> github에서 내려 받기
git연결
3)Oralce과 Mybatis를 사용하기 위한 이존성 라이브러리 설정
=>pom.xml 파일에 작성
<!-- 중앙저장소 이외의 곳에서 라이브러리를 다운로드 받을 때 다운로드 받는 위치를 설정하는 태그 -->
<repositories>
<repository>
<id>oracle</id>
<name>ORACLE JDBC Repository</name>
<url>http://maven.jahia.org/maven2</url>
</repository>
</repositories>
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc7</artifactId>
<version>12.1.0.2</version>
</dependency>
=>oracle, spring-jdbc,mybatis,mybatis-spring,lombok
4) 소스 코드를 작성할 src/main/java 디렉토리를 생성
5) java version을 1.8 로 변경
프로젝트를 선택하고 마우스 오른쪽을 클릭해서 [build path]-[configure bean path] 를 선택
jre system libary를 선택한 후 edit버튼을 눌러서 변경
=>배포할 때 상대방 컴퓨터에 설치된 자바의 최소 버전 설정이기도 합니다.
ios 13에서 개발하면 ios 13밖에 못 받는다.하위버전 안된다.
안드로이드는 os업데이트 잘 안한다.
전체 데이터 조회
select * from goods;
code를 가지고 하나의 데이터를 조회
select * from goods where code = 1;
데이터 삽입
insert into goods(code, name, manufacture, price)
values(3, '배','나주',4500)
데이터 갱신 -기본키를 조건으로 해서 나머지 컬럼을 수정
update goods set name ='', manufacture ='이천',price=60000
where code = 3;
데이터 삭제 -기본키를 조건으로 해서 삭제
delete from goods
where code = 4;
6)Goods 테이블의 데이터를 표현할 DTO클래스를 생성
db.mybatis.domain.Good
@Data
public class Good {
private int code;
private String name;
private String manufacture;
private int price;
}
7)Dao역할을 수행할 인터페이스를 생성
=>db.mybatis.dao.GoodDao
열이 1개 : 기본자료형 ,String ,Date
열이 여러개 : Map, Dto(사용자 정의 클래스)
행이 여러개 일 때는 위의 자료형의 LiST
행이 1개이면 위의 자료형 그대로
public interface GoodDao {
//goods테이블의 전체 데이터를 가져오는 메소드
//public 리턴타입 이름(매개변수);
@Select("select * from goods")
public List<Good> allGood();
//code를 가지고 goods 테이블에서 데이터르 조회하는 메소드
//code는 기본키
@Select("select * from goods where code = #{code}")
public Good detailGood(int code);
//데이터를 추가하는 메소드
@Insert("insert into goods(code, name, manufacture, price) "
+ "values (#{code},#{name},#{manufacture},#{price})")
public int insertGood(Good good);
//데이터를 수정하는 메소드
//insert해도 되고 update해도 된다.
@Update("update goods set name= #{name}, manufacture = #{manufacture}, price = #{price} "
+ "where code = #{code}")
public int updateGood(Good good);
//데이터를 삭제하는 메소드
@Delete("delete goods where code=#{code}")
public int deleteGood(int code);
}
8)spring설정 파일을 생성하고 GoodDaof를 위한 설정을 작성
src/main/resources
java - source(컴파일)
resource- file(컴파일 안해도 되는 것)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 스프링에서 데이터베이스를 사용할 때 접속 정보를 저장할 bean -->
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
<!-- 데이터베이스 종류 -->
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
<!-- 데이터베이스 위치 -->
<!-- 데이터베이스 응용법 마다 다르다. -->
<property name="url" value="jdbc:oracle:thin:@ip주소:1521:xe"></property>
<property name="username" value="user29"></property>
<property name="password" value="user29"></property>
</bean>
<!-- MyBatis를 인터페이스를 이용해서 사용할 떄 필요한 Bean -->
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
<property name="dataSource" ref="dataSource"></property>
</bean>
<bean class="org.mybatis.spring.mapper.MapperFactoryBean" id="goodDao">
<property name="sqlSessionFactory" ref ="sqlSessionFactory"></property>
<property name="mapperInterface" value="db.mybatis.dao.GoodDao"></property>
</bean>
<!-- GoodDao Bean -->
<!-- bean을 자동으로 만들어주는 작업이 있다. -->
<!-- <bean id ="sample" class="mb.mybatis.dao.GoodDao"/> -->
</beans>
9)GoodDao 인터페이스의 Bean을 자동으로 생성되도록 설정
=>인터페이스 나 클래스 위에 @Component, @Controller, @Service,@Repository어노페이션 중 하나를 추가하고 spring설정 파일에 <contextannotaion-config/>,<context:component-scan base-package="패키지경로" />
10)main메소드를 소유한 클래스를 만들고 GoodDao객체를 사용
package db.mybatis;
import org.springframework.context.support.GenericXmlApplicationContext;
import db.mybatis.dao.GoodDao;
import db.mybatis.domain.Good;
public class MyBatisMain {
public static void main(String[] args) {
GenericXmlApplicationContext context = new GenericXmlApplicationContext("classpath:applicationContext.xml");
//GoodDao dao = context.getBean("goodDao",GoodDao.class);
//아이디 없이 자료형으로 BEAN을 찾아오기
GoodDao dao = context.getBean(GoodDao.class);
//System.err.println(dao.allGood());
//전페 데이터를 가져오는 메소드를 호출해서 확인
//List를 리턴하는 경우는 데이터가 없으면 List는 만들고 size가 0
//size가 0인 경우는 for문이기 깨문이다.
/*
List<Good> list = dao.allGood();
for(Good good:list) {
System.out.println(good);
}
*/
//code를 1개의 데이터를 리턴받는 메소드를 출력
//1개의 행을 리턴하는 메소드는 리턴할 데이터가 있으면 데이터를 리턴하고
//없으면 null을 리턴합니다.
/*
Good good = dao.detailGood(2);
System.out.println(good);
*/
//삽입하는 메소드 호출
/*
Good good = new Good();
good.setCode(1);
good.setName("감귤");
good.setManufacture("제주");
good.setPrice(300);
try {
int result = dao.insertGood(good);
if(result>0) {
System.out.println("데이터 삽입 성공");
}else {
System.out.println("데이터 삽입 실패");
}
}catch(Exception e) {
System.out.println("데이터 삽입 실패");
e.printStackTrace();
}
*/
/*
Good good = new Good();
good.setCode(1);
good.setName("감자");
good.setManufacture("고성");
good.setPrice(3050);
try {
int result = dao.updateGood(good);
if(result>0) {
System.out.println("데이터 수정 성공");
}else {
System.out.println("수정할 데이터가 없음");
}
}catch(Exception e) {
System.out.println("데이터 수정 실패");
e.printStackTrace();
}
*/
try {
int result = dao.deleteGood(3);
if(result>0) {
System.out.println("데이터 삭제 성공");
}else {
System.out.println("삭제할 데이터가 없음");
}
}catch(Exception e) {
System.out.println("데이터 삭제 실패");
e.printStackTrace();
}
context.close();
}
}
**트랜잭션
=>Transaction한번에 수행되어야 하는 작업의 논리적인 단위
가게에서 물건을 구입한다변 가게 입장에서는 물건을 주고 금액을 받아야 합니다.
고객입장에서 보면 금액을 지불하고 물건을 받아야 합니다.
데이터베이스 입장에서 보면 가게는 금액을 수정하고 물건에 대한 정보를 수정해야 합니다.
가게 입장에서는 2개의 sql구문이 수행되어야 합니다.
고객입장에서보면 금액이 수정되어야 하고 물건에 대한 정보도 수정되어야 합니다.
고객입장에서도 2개의 sql문이 수행되어야 합니다.
dao가 sql을 4개를 실행해야 합니다.
이 경우 하나의 sql수행이 성공했다고 commit을 해버리면 잘못된 결과가 저장될 수 있습니다.
이런 경우는 4개의 sql이 모두 성공한 경우만 성공이고 나머지 경우는 실패라서 초기 상태로 되돌려야 합니다.
이렇게 한꺼번에 수행되어야 하는 sql을 하나로 묶은 것을 트랜잭션이라고 합니다.
1.트랜잭션 처리 방식
1)manual commit: 직접 commit과 rollback을 수행
2)auto commit:하나의 sql구문이 성공적으로 수행되면 자동으로 commit을 수행
=>java의 jdbc와 Mybatis는 근본적으로 auto commit
2.mybatis 에서의 트랜잭션 처리(manual commit 사용ㅇ)
=>스프링 설정 파일에서 트랜잭션 매니져 객체를 생성
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id ="transactionManager">
<property name="dataSource" ref="dataSourceId" />
</bean>
=>트랜잭션 관리를 annotation으로 할 수 있도록 해주는 객체를 생성
<tx:annotation-driven transaction-manager ="앞에서 만든 bean의 id"/>
=>메소드 위에 @Transaction을 추가하면 메소드 수행도중 예외가 발생하면 rollback하고 예외가 발생하지 않으면 commit을 수행해 줍니다.
=>트랜잭션은 dao클래스에 적용하는 것이 아니고 Service나 controller에 적용해야 합니다.
거래에 묶어 주어야 한다.
3.mybatis의 트랜잭션 처리 실습
1)service 클래스를 생성하고 데이터베이스 삽입 메소드를 2번 호출하도록 만들기
=>db.mybytis.service.GoodService
package db.mybatis.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import db.mybatis.dao.GoodDao;
import db.mybatis.domain.Good;
//이 클래스의 bean은 자동 생성
@Service
public class GoodService {
//동일한 자료형의 bean이 있으면 자동으로 주입해주는 어노테이션
@Autowired
private GoodDao goodDao;
//데이터를 삽입하는 메소드
public int insertGood(Good good) {
goodDao.insertGood(good);
return goodDao.insertGood(good);
}
}
2)스프링 설정 파일에 GoodService인스턴스를 자동 생성하도록 설정
=>context네임스페이스 추가
=>코드 추가
<!-- 어노테이션 설정을 사용할 수 있도록 해주는 태그 -->
<context:annotation-config></context:annotation-config>
<!-- bean자동 생성 패키지 등록 -->
<!-- db에 어노페이션 있으면 자동으로 만들어진다. -->
<context:component-scan base-package="db"></context:component-scan>
3) main메소드를 수정해서 호출하기
GenericXmlApplicationContext context = new GenericXmlApplicationContext("classpath:applicationContext.xml");
//삽입할 데이터 생성
Good good = new Good();
good.setCode(1);
good.setName("무화과");
good.setManufacture("목포");
good.setPrice(3000);
//GoodService 객체 가져오기
GoodService service = context.getBean(GoodService.class);
//메소드 호출
service.insertGood(good);
=>service 의 insertGoode은 동일한 데이터를 2번 삽입하는 메소드 잆니다.
동일한 code를 2번 삽입할려고 해서 첫번째 데이터는 정상적으로 삽입이 되고 두번째 삽입할려고 할 때 예외가 발생합니다.
트랜잭션을 적용하지 않아서 auto-commit입니다.
첫번째 데이터가 삽입하는데 성공하면 데이터베이스에 반영되고 두번째 sql을 실행합니다.
첫번째 데이터는 삽입에 성공하고 두번쨰 삽입은 실패입니다.
4) 스프링 설정 파일에 mybatis 트랜잭션 적용을 위한 bean을 생성
=>tx 네임스페이스를 추가
=>코드 작성
<!-- Mybatis 트랜잭션 적용을 위한 클래스의 객체 생성 -->
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 트랜잭션을 어노페이션으로 설정하기 위한 설정 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
5) Service메소드에 트랜잭션을 적용
6) main메소드를 수정하고 실행
GenericXmlApplicationContext context = new GenericXmlApplicationContext("classpath:applicationContext.xml");
//삽입할 데이터 생성
Good good = new Good();
good.setCode(4);
good.setName("무화과");
good.setManufacture("목포");
good.setPrice(3000);
//GoodService 객체 가져오기
GoodService service = context.getBean(GoodService.class);
//메소드 호출
service.insertGood(good);
=>실행하면 두번째 삽입을 수행해다가 예외가 발생하면 첫번째 삽입은 성공했지만 하나의 트랜잭션으로 묶여 있어서 같이 취소됩니다.
**hibernate
=>ORM(Object Relation Mapper):하나의 테이블 과 클래스를 매핑하는 방식의 데이터베이스 프레임워크로 하나의 행을 하나의 인스턴스로 표현
=>sql을 이용하기도 하고 sql없이도 데이터베이스 작업이 가능
기본키를 가지고 하는 작업은 아주 쉽게 처리할 수 있습니다.
=>java의 orm표준 spec을 jpa라고 이에 대한 구현체가 hibernate
현재는 대다수의 프로그래밍 언어들에 orm 프레임워크가 구현되어 있습니다.
2.Hibernate의 장점
=>복잡한 jdbc코드를 제거
=>spring과의 통합 기능 제공
=>성능이 mybatis보다 우수 :카카오나 배달의 민족이 hibernate로 구현
3.단점
=>초기 설정이 mybatis에 비해서 어려움
=>si업계애서는 mybatis를 선택하고 솔루션 업계에서는 hibernate
r->데이터 통계분석
분석만 하면 r이 났다.
python
4.자료형 매핑
integer(number) :int, java.lang.Integer
long(number) : long, java.lang.long
double(number): double, java.lang.double
boolean yes/no , true/false: boolean java.lang.Boolean
date: java.sql.Date, java.util.Date
time: java.sql.Time, java.util.Date
timestamp: java.sql.Timestamp, java.util.Date
char, varchar(varchar2 - Oracle), string,clob- oracle, text
blob(파일의 내용 - 바이트 배열): java.sql.Blob
5.하이버네이트 Mapper만들기 - xml파일
<hibernate-mapping package="테이블과 매핑할 패키지 경로">
<class name ="클래스이름" table ="테이블이름">
<id name ="변수이름" column ="컬럼이름"></id> //기본키 설정
<property name="변수이름" column ="컬럼이름"/>
... 프로퍼티 추가
</class>
</hibernate-mapping>
6) 하이버네이트 bean생성
1)PersistencyExceptionTranslationPostProcessor클래스의 bean 생성
2)LocalSessionFactoryBean클래스의 bean을 생성
=>DataSOurce, 하이버네이트 매퍼 파일, 데이터베이스 종류가 필요
7.하이버네이트 bean 객체 사용
=>sessionFactory 클래스의 bean 을 주입받아서 사용
getCurrenSession()을 호출하고 필요한 메소드를 호출
8.의존성 라이브러리
=>spring-orm, hibernate
**Goods테이블의 crud작업을 hibernate를 이용해서 처리
1. Project생성
2. pom.xml파일에 hibernate를 사용을 위한 의존성을 설정
=>oracle, spring-jdbc,spring-orm, hibernate
3. 테이블과 매핑할 dto클래스를 생성
=>db.hibernate.domain.Good
@Data
public class Good {
private int code;
private String name;
private String manufacture;
private int price;
}
4. dto클래스와 연동할 테이블을 매핑하는 매핑 파일을 생성
=>db.hibernate.dao패키지에 good.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="db.hibernate.domain">
<!-- 데이터베이스에서는 값만 대소문자 구분 -->
<class name="Good" table="Goods">
<id name="code" column="code"></id>
<property name="name" column="name"></property>
<property name="manufacture" column="manufacture"></property>
<property name="price" column="price"></property>
</class>
</hibernate-mapping>
pk가 여러개 있을 경우
class를 하나 만들거나 map을 하거나 해서
<id name="code" column="code1,code2"></id>
이런식으로 묶어면 된다.
5 src/main/resources디렉토리에 spring bean configuration파일을 추가
=>hibernateContext.xml
=>DataSource, hibernate관련 bean
1)context와 tx네임스페이스 추기
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
<!-- 어노페이션을 이용한 bean생성을 위한 설정 -->
<context:annotation-config/>
<!-- 자동으로 bean을 생성할 패키지를 위한 서정 -->
<!-- dao는 base-package="db" 여기 안에 만들어야 한다. -->
<context:component-scan base-package="db"></context:component-scan>
<!-- 트랜잭션을 어노페이션을 이용해서 사용할 수 있도록 해주는 설정 -->
<tx:annotation-driven/>
<!-- datasource -->
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
<!-- 데이터베이스 종류 -->
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
<!-- 데이터베이스 위치 -->
<!-- 데이터베이스 응용법 마다 다르다. -->
<property name="url" value="jdbc:oracle:thin:@ip주소:1521:xe"></property>
<property name="username" value="user29"></property>
<property name="password" value="user29"></property>
</bean>
<!-- 하이버네이트 연동 Bean생성 -->
<bean class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"
id="sessionFactory">
<property name="dataSource" ref="dataSource"></property>
<!-- hibernate 설정 파일 등록
설정 파일이 여러 개이면 value를 추가-->
<property name="mappingResources">
<list>
<!-- 테이블이 여러개면 계속 추가하면 도니다. -->
<value>db/hibernate/dao/good.hbm.xml</value>
</list>
</property>
<!-- 사용할 데이터베이스 종류 설정
데이터베이스 종류 별로 고정된 값-->
<property name="hibernateProperties">
<value>
hibernate.dialect = org.hibernate.dialect.Oracle10gDialect
</value>
</property>
</bean>
<!-- 하이버네이트 트랜잭션 사용 bean -->
<bean class="org.springframework.orm.hibernate5.HibernateTransactionManager"
id="transactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor">
</bean>
</beans>
6.Dao클래스를 만들어서 데이터를 삽입하는 메소드 구현
=>db.hiberante.dao.GoodDao
//bean생성을 자동으로 해주는 어노테인션
@Repository
public class GoodDao {
//하이버네이트 사용 변수 생성
@Autowired
private SessionFactory sessionFactory;
//데이터 삽입 하는 매소드
//@Transactional
public int insertGood(Good good) {
sessionFactory.getCurrentSession().save(good);
return 1;
}
}
7.main메소드를 소유한 HibernateMain클르새를 작성
public class HibernateMain {
public static void main(String[] args) {
GenericXmlApplicationContext context = new GenericXmlApplicationContext("classpath:hibernateContext.xml");
GoodDao dao = context.getBean(GoodDao.class);
Good good= new Good();
good.setCode(6);
good.setName("자동차");
good.setManufacture("울산");
good.setPrice(2000000000);
dao.insertGood(good);
context.close();
}
}
8. 실행하고 데이터베이스 확인
오류 부분 수정:
<context:component-scan base-package="db.hibernate"></context:component-scan>
이 부분으로 수정
GoodDao.java에서
//데이터 삽입 하는 매소드
@Transactional
public int insertGood(Good good) {
sessionFactory.getCurrentSession().save(good);
return 1;
}
정상 결과 =>
디비 확인=>
9.데이터 수정 기능 구현 -기본키를 가지고 조회해서 나머지 데이터 변경
1)Dao클래스에 메소드 추가
// 데이터 수정 하는 매소드
@Transactional
public void updateGood(Good good) {
sessionFactory.getCurrentSession().update(good);
}
2)main메소드 수정하고 테스트
public class HibernateMain {
public static void main(String[] args) {
GenericXmlApplicationContext context = new GenericXmlApplicationContext("classpath:hibernateContext.xml");
GoodDao dao = context.getBean(GoodDao.class);
Good good= new Good();
good.setCode(6);
good.setName("소고기");
good.setManufacture("뉴질랜드");
good.setPrice(150000);
dao.updateGood(good);
context.close();
}
}
10.삭제 기능 구현
1)Dao클래스에 메소드 구현
// 데이터 삭제 하는 매소드
@Transactional
public void deleteGood(Good good) {
sessionFactory.getCurrentSession().delete(good);
}
2) main메소드를 수정하고 테스트
Good good= new Good();
good.setCode(6);
good.setName("소고기");
good.setManufacture("뉴질랜드");
good.setPrice(160000);
//dao.updateGood(good);
dao.deleteGood(good);
이 3개는 정확하지 않아도 삭제가 된다.
good.setName("소고기");
good.setManufacture("뉴질랜드");
good.setPrice(160000);
기본키로 한다.
기본키로 하면 수월하는 데 그래서 잘 고려해야 한다.
micro service ->소형 프로젝트
11.테이블의 데이터 전체를 가져오는 메소드
1)Dao클래스에 메소드를 추가
// 테이블의 데이털르 전부 가져오는 메소드
// public ? allGood(?){
@Transactional
public List<Good> allGood() {
// good클래스와 연결된 테이블의 모든 데이터 찾아오기
return sessionFactory.getCurrentSession().createCriteria(Good.class).list();
}
// code를 가지고 하나의 행을 찾아오는 메소드
// public ? getGood(?){
@Transactional
public Good getGood(int code) {
return sessionFactory.getCurrentSession().get(Good.class, code);
}
자료형을 확인하기
기본형
string date
map , (dict)
dto클래스
python의 분석의 결과를 주로 tuple로 준다.
dict {"sloop":7,"interrpte":8}
python에서는 (7,8)
type로 해서 해야 한다.
python =>type , dir, help
2)main 메소드 수정 및 확인
package db.hibernate;
import java.util.List;
import org.springframework.context.support.GenericXmlApplicationContext;
import db.hibernate.dao.GoodDao;
import db.hibernate.domain.Good;
public class HibernateMain {
public static void main(String[] args) {
GenericXmlApplicationContext context = new GenericXmlApplicationContext("classpath:hibernateContext.xml");
GoodDao dao = context.getBean(GoodDao.class);
/*
Good good= new Good();
good.setCode(6);
good.setName("자동차");
good.setManufacture("울산");
good.setPrice(2000000000);
dao.insertGood(good);
*/
/*
Good good= new Good();
good.setCode(6);
good.setName("소고기");
good.setManufacture("뉴질랜드");
good.setPrice(160000);
dao.updateGood(good);
*/
/*
Good good= new Good();
good.setCode(6);
dao.deleteGood(good);
*/
List<Good> list =dao.allGood();
for(Good good: list) {
System.out.println(good);
}
dao.getGood(1);
context.close();
}
}
12.Dao 메소드에서 sql을 이용해서 데이터를 가져오도록 수정
r = a+b
k = r+c
k = a+b+c
@Transactional
public List<Good> allGood() {
// good클래스와 연결된 테이블의 모든 데이터 찾아오기
//return sessionFactory.getCurrentSession().createCriteria(Good.class).list();
//sql을 이용해서 데이터 가져오기
//메소드에 리턴 값을 가지고 다른 메소드를 호출하느 것을
//메소드 체이닝이라고 합니다.
//r에서 %>%와 비슷하다.
return sessionFactory.getCurrentSession().createSQLQuery("select * from goods").addEntity(Good.class).list();
}
**개발분야
=>si업체 :oracle+ mybatis조합에 View출력
=>중격기업 : mysql(Maria db)+ hibernate 조합에 데이터 출력(pdf,excel,csv, json,xml)이나 Mongo Db 사용
mongo db+hibernate =>이것은 안된다.
pk가 두개 있을 경우 :
<composite-id>
<key-property name="code" column="" />
<key-property name="code" column="" />
</composite-id>
class Inner{
private int code;
private String name;
}
class DTO{
private Inner inner;
}
@Transactional
public Good getGood1(int code,String name) {
//return sessionFactory.getCurrentSession().get(Good.class, code);
//return sessionFactory.getCurrentSession().createSQLQuery("select * from goods where code = :code").addEntity(Good.class);
List<Good> list = sessionFactory.getCurrentSession().createSQLQuery("select * from Goods where code=:code and name=:name").addEntity(Good.class).setInteger("code", code).setString("name", name).list();
if(list == null || list.size() < 1) return null;
return list.get(0);
}
dao.getGood1(1,"무화과");