㈠ oracle中的blob類型欄位中的文本內容怎樣讀取和存入
不知道你用的編程語言是什麼 若是java 的話 直接從資料庫裡面拿（如果有hibernate支持）那就domain.getBlob()。然後用流去將blob轉換成string 具體怎麼做 網路。
存值的時候是將表單的string轉換成blob再塞進資料庫。newSerialBlob(String對象的.getBytes())
㈡ 如何把文件傳入mysql中的blob欄位中
1、用戶上傳文檔後，把文檔存儲到某個路徑下，然後在資料庫中存儲這個路徑和文檔名
2、用戶上傳文檔後，進行二進制讀取（流處理），然後把讀取出來的二進制存儲到資料庫中
首先我們要進行讀取文件
$myfile = fopen("webdictionary.txt", "r") or die("Unable to open file!");
然後把 $myfile 存儲到mysql中
sql ="insert into table_name (fn) values($myfile)""
這樣就把文檔轉變成二進制之後，存儲到了mysql資料庫，下次取出時，只需要把取出的數據存儲到一個文檔中
㈢ 字元串如何存到資料庫blob欄位
將字元串轉換成byte數組String.getBytes()，然後放進一個ByteArrayInputStream輸入流中即可存入BLOB欄位中
PreparedStatement.setBlob(int parameterIndex, InputStream inputStream)
㈣ 如何把blob類型數據存到資料庫csdn
BLOB (binary large object)----二進制大對象，是一個可以存儲二進制文件的容器。
在計算機中，BLOB常常是資料庫中用來存儲二進制文件的欄位類型。
BLOB是一個大文件，典型的BLOB是一張圖片或一個聲音文件，由於它們的尺寸，必須使用特殊的方式來處理（例如：上傳、下載或者存放到一個資料庫）。
根據Eric Raymond的說法，處理BLOB的主要思想就是讓文件處理器（如資料庫管理器）不去理會文件是什麼，而是關心如何去處理它。
但也有專家強調，這種處理大數據對象的方法是把雙刃劍，它有可能引發一些問題，如存儲的二進制文件過大，會使資料庫的性能下降。在資料庫中存放體積較大的多媒體對象就是應用程序處理BLOB的典型例子。
㈤ 如何將對象持久化到資料庫中BLOB
對象持久化，也就是可以把這個對象永遠的保存起來，這里的保存不僅是對象本身，還包括他的屬性和所依賴的其他類。通常，對象可以持久化到文件或者是資料庫中。我這里只介紹如何將對象存儲到資料庫中。恰巧Oracle資料庫為我們提供了這樣的方便。
在Oracle中，有一種blog的欄位類型，它是用來存儲大量的二進制數據的。我們就利用這個欄位去存儲對象信息。
首先建立一個測試表：
create table TESTBLOB
(
NAME VARCHAR2(50) not null,
CONTENT BLOB not null,
ID NUMBER(8) not null
)alter table TESTBLOB
add constraint IDFORTEST primary key (ID);
只用三個欄位，其中id是屬性，content是我們要存儲對象的欄位。
先來看看我們要存入的對象：
import java.io.Serializable;
import java.util.Date;
import java.util.List;
public class TestObject implements Serializable {
private static final long serialVersionUID = 4558876142427402513L;
/**
* @param args
*/
private String name;
private String password;
private Date date;
private List<City> cityList;
public List<City> getCityList() {
return cityList;
}
public void setCityList(List<City> cityList) {
this.cityList = cityList;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
記得要實現Serializable介面，可以看到這是一個包含了string，date，和list類型的對象，為了給測試增加復雜度，我們的list是另外一個對象（city）的list，如下：
import java.io.Serializable;
public class City implements Serializable{
private static final long serialVersionUID = 4558876127402513L;
private String name;
private String code;
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
City對象包括了城市名稱和區號。下面是主要的應用了。
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import oracle.sql.BLOB;
public class Test {
public static void main(String[] args) {
//創建測試用對象
City beijing = new City();
beijing.setName("北京");
beijing.setCode("010");
City shanghai = new City();
shanghai.setName("上海");
shanghai.setCode("020");
City tianjin = new City();
tianjin.setName("天津");
tianjin.setCode("021");
List<City> cityList = new ArrayList<City>();
cityList.add(beijing);
cityList.add(shanghai);
cityList.add(tianjin);
TestObject obj = new TestObject();
obj.setName("yangsq");
obj.setPassword("111");
obj.setDate(new Date());
obj.setCityList(cityList);
try{
//將對象存入blob欄位
ByteArrayOutputStream byteOut=new ByteArrayOutputStream();
ObjectOutputStream outObj=new ObjectOutputStream(byteOut);
outObj.writeObject(obj) ;
final byte[] objbytes=byteOut.toByteArray();
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection con = DriverManager.getConnection(
"jdbc:oracle:thin:@***.***.***.***:1521:****", "yangsq", "yangsq");
con.setAutoCommit(false);
Statement st = con.createStatement();
st.executeUpdate("insert into TESTBLOB (ID, NAME, CONTENT) values (1, 'test1', empty_blob())");
ResultSet rs = st.executeQuery("select CONTENT from TESTBLOB where ID=1 for update");
if (rs.next()) {
BLOB blob = (BLOB) rs.getBlob("CONTENT");
OutputStream outStream = blob.getBinaryOutputStream();
outStream.write(objbytes, 0, objbytes.length);
outStream.flush();
outStream.close();
}
byteOut.close();
outObj.close();
con.commit();
//取出blob欄位中的對象，並恢復
rs = st.executeQuery("select CONTENT from TESTBLOB where ID=1");
BLOB inblob = null;
if (rs.next()) {
inblob = (BLOB) rs.getBlob("CONTENT");
}
InputStream is = inblob.getBinaryStream();
BufferedInputStream input = new BufferedInputStream(is);
byte[] buff = new byte[inblob.getBufferSize()];
while(-1 != (input.read(buff, 0, buff.length)));
ObjectInputStream in =
new ObjectInputStream(
new ByteArrayInputStream(
buff));
TestObject w3 = (TestObject)in.readObject();
System.out.println(w3.getName());
System.out.println(w3.getPassword());
System.out.println(w3.getDate());
List<City> list = w3.getCityList();
for(City city : list){
System.out.println(city.getName() + " " + city.getCode());
}
st.close();
con.close();
} catch (Exception ex) {
ex.printStackTrace();
System.exit(1);
}
}
}
代碼的藍色部分創建了要存儲的對象。再看紅色的對象寫入部分，它首先把對象轉化成二進制流的形式。對於blob欄位，我們不能簡單的在insert時插入，實際上，insert時，對於blob欄位，只能先插入一個空的blob對象empty_blob()，然後再進行"select CONTENT from TESTBLOB where ID=1 for update"對blob欄位進行更新。返回後，我們只要把對象的二進制流寫入即可。
OutputStream outStream = blob.getBinaryOutputStream();
outStream.write(objbytes, 0, objbytes.length);
需要注意的是，上述步驟必須設置con.setAutoCommit(false)，否則oracle會拋出異常。
接下來，綠色的代碼是讀取資料庫中blob欄位的對象，並恢復。我們要知道的是，所有對blob欄位的操作都是二進制的，即插入時是二進制流，讀出時也是二進制流。然後用io修飾器（ObjectInputStream）去修飾。以前學習java時，感覺它的io好繁瑣啊，現在感覺還真是各有其用。下面是測試的輸出結果。
yangsq
111
Tue Mar 27 12:11:28 CST 2007
北京 010
上海 020
天津 021
需要說明一下，buff的size一定要足夠大，否則將拋出異常。在這里，我使用的是inblob.getBufferSize()來設置buff的size，這並不是一種好的方法，因為一般inblob.getBufferSize()都是32768，很可能出現異常，所以這個size最好自己設置，或系統運行時刻設置（幸好java提供數組長度的運行時刻設置）。
㈥ 如何向各種資料庫中寫入blob類型的記錄
1.使用jdk中的方法進行傳輸。在ResultSet 中有getBlob()方法，在PreparedStatement中有setBlob()方法，所以大多數人都會嘗試setBlob
(),getBlob() 進行讀寫，或者兩個資料庫之間BLOB的傳輸。這種方法實際上是行不通的，據網上的一些資料介紹，說sun官方的文檔有些方法
都是錯誤的。
2.使用ResultSet.getBinaryStream 和PreparedStatement.setBinaryStream對BLOB進行讀寫或兩個資料庫間的傳輸。這種方法我自己嘗試過，
發現，如果BLOB中存儲的是文本文件的話，就沒問題，如果是二進制文件，傳輸就會有問題。
根據自己的經驗，以及查閱了Oracle的官方文檔，都是使用如下處理方法：
1.新建記錄，插入BLOB數據
1.1首先新建記錄的時候，使用oracle的函數插入一個空的BLOB，假設欄位A是BLOB類型的:
insert xxxtable(A,B,C) values(empty_blob(),'xxx','yyyy')
1.2後面再查詢剛才插入的記錄，然後更新BLOB，在查詢前，注意設置Connection的一個屬性:
conn.setAutoCommit(false);如果缺少這一步，可能導致fetch out of sequence等異常.
1.3 查詢剛才插入的記錄,後面要加「 for update 」,如下：
select A from xxxtable where xxx=999 for update ,如果缺少for update，可能出現row containing the LOB value is not locked
的異常
1.4 從查詢到的 BLOB欄位中，獲取blob並進行更新，代碼如下：
BLOB blob = (BLOB) rs.getBlob("A");
OutputStream os = blob.getBinaryOutputStream();
BufferedOutputStream output = new BufferedOutputStream(os);
後面再使用output.write方法將需要寫入的內容寫到output中就可以了。例如我們將一個文件寫入這個欄位中：
BufferedInputStream input = new BufferedInputStream(new File("c://hpWave.log").toURL().openStream());
byte[] buff = new byte[2048]; //用做文件寫入的緩沖
int bytesRead;
while(-1 != (bytesRead = input.read(buff, 0, buff.length))) {
output.write(buff, 0, bytesRead);
System.out.println(bytesRead);
}
上面的代碼就是從input里2k地讀取，然後寫入到output中。
1.5上面執行完畢後，記得關閉output,input,以及關閉查詢到的ResultSet
1.6最後執行conn.commit();將更新的內容提交，以及執行conn.setAutoCommit(true); 改回Connction的屬性
㈦ Mysql中如何實現Blob的存取
此實現為用java訪問mysql的blob,對圖片進行存取
/**
* Title: BlobPros.java
* Project: test
* Description: 把圖片存入mysql中的blob欄位，並取出
* Call Mole: mtools資料庫中的tmp表
* File: C:downloadsluozsh.jpg
* Copyright: Copyright (c) 2003-2003
* Company: uniware
* Create Date: 2002.12.5
* @Author: ChenQH
* @version 1.0 版本*
*
* Revision history
* Name Date Description
* ---- ---- -----------
* Chenqh 2003.12.5 對圖片進行存取
*
* note: 要把資料庫中的Blob欄位設為longblob
*
*/
//package com.uniware;
import java.io.*;
import java.util.*;
import java.sql.*;
public class BlobPros
{
private static final String URL = "jdbc:mysql://10.144.123.63:3306/mtools?user=wind&password=123&useUnicode=true";
private Connection conn = null;
private PreparedStatement pstmt = null;
private ResultSet rs = null;
private File file = null;
public BlobPros()
{
}
/**
* 向資料庫中插入一個新的BLOB對象(圖片)
* @param infile 要輸入的數據文件
* @throws java.lang.Exception
*/
public void blobInsert(String infile) throws Exception
{
FileInputStream fis = null;
try
{
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
conn = DriverManager.getConnection(URL);
file = new File(infile);
fis = new FileInputStream(file);
//InputStream fis = new FileInputStream(infile);
pstmt = conn.prepareStatement("insert into tmp(descs,pic) values(?,?)");
pstmt.setString(1,file.getName()); //把傳過來的第一個參數設為文件名
//pstmt.setBinaryStream(2,fis,(int)file.length()); //這種方法原理上會丟數據，因為file.length()返回的是long型
pstmt.setBinaryStream(2,fis,fis.available()); //第二個參數為文件的內容
pstmt.executeUpdate();
}
catch(Exception ex)
{
System.out.println("[blobInsert error : ]" + ex.toString());
}
finally
{
//關閉所打開的對像//
pstmt.close();
fis.close();
conn.close();
}
}
/**
* 從資料庫中讀出BLOB對象
* @param outfile 輸出的數據文件
* @param picID 要取的圖片在資料庫中的ID
* @throws java.lang.Exception
*/
public void blobRead(String outfile,int picID) throws Exception
{
FileOutputStream fos = null;
InputStream is = null;
byte[] Buffer = new byte[4096];
try
{
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
conn = DriverManager.getConnection(URL);
pstmt = conn.prepareStatement("select pic from tmp where id=?");
pstmt.setInt(1,picID); //傳入要取的圖片的ID
rs = pstmt.executeQuery();
rs.next();
file = new File(outfile);
if(!file.exists())
{
file.createNewFile(); //如果文件不存在，則創建
}
fos = new FileOutputStream(file);
is = rs.getBinaryStream("pic");
int size = 0;
/* while(size != -1)
{
size = is.read(Buffer); //從資料庫中一段一段的讀出數據
//System.out.println(size);
if(size != -1) //-1表示讀到了文件末
fos.write(Buffer,0,size);
} */
while((size = is.read(Buffer)) != -1)
{
//System.out.println(size);
fos.write(Buffer,0,size);
}
}
catch(Exception e)
{
System.out.println("[OutPutFile error : ]" + e.getMessage());
}
finally
{
//關閉用到的資源
fos.close();
rs.close();
pstmt.close();
conn.close();
}
}
public static void main(String[] args)
{
try
{
BlobPros blob = new BlobPros();
//blob.blobInsert("C:Downloadsluozsh1.jpg");
blob.blobRead("c:/downloads/1.jpg",47);
}
catch(Exception e)
{
System.out.println("[Main func error: ]" + e.getMessage());
}
}
}
㈧ 上Mysql後，怎麼存入和取出blob數據
讀取 BLOB數據： 首先做查詢，拿到查詢結果ResultSet rs = XXXX (和普通數據查詢一樣) 然後：Blob blob = rs.getBlob("欄位名"); 拿到你的Blob ，
㈨ 資料庫中的Blob是怎麼存儲的啊
BLOB 欄位，英文 binary large object 的縮寫，意即：二進制大對象，這種欄位類型主用用於存儲二進制文件的容器，至於存儲的二進制是內容是什麼，要根據用戶的需要來寶，比如：可以是一個BMP圖像，也可以是一段影像，也可以是一個文件等等。
至於blob欄位的存儲，要根據不同資料庫來定，有時還要根據編程語言來定。
㈩ 什麼是blob，mysql blob大小配置介紹
BLOB介紹
BLOB (binary large object)，二進制大對象，是一個可以存儲二進制文件的容器。在計算機中，BLOB常常是資料庫中用來存儲二進制文件的欄位類型。BLOB是一
個大文件，典型的BLOB是一張圖片或一個聲音文件，由於它們的尺寸，必須使用特殊的方式來處理（例如：上傳、下載或者存放到一個資料庫）。根據Eric Raymond的
說法，處理BLOB的主要思想就是讓文件處理器（如資料庫管理器）不去理會文件是什麼，而是關心如何去處理它。但也有專家強調，這種處理大數據對象的方法是把雙
刃劍，它有可能引發一些問題，如存儲的二進制文件過大，會使資料庫的性能下降。在資料庫中存放體積較大的多媒體對象就是應用程序處理BLOB的典型例子。