如何在java类中向oracle数据库写入Date类型的日期

Posted 2023-05-13

数据库中的Date类型是日期类型也就是说，根本就没有时间部分。你可以将数据库的相应字段设置为Timestamp类型。或者直接设置为varchar 参考技术A 在java端,将参数绑定为Date就可以。
如果非要在数据库转换就
insert into aa (id,tdate) values(1,to_date(?,'yyyy-mm-dd'))
问号的位置放你自己的参数。本回答被提问者采纳

在 Dart 中向/从套接字数据写入/读取字节数

【中文标题】在 Dart 中向/从套接字数据写入/读取字节数

【英文标题】：writing/reading number of bytes to/from socket data in Dart

【发布时间】：2015-05-18 19:44:02

【问题描述】：

在以下服务器/客户端套接字代码中，服务器尝试发送从 0 到 1023 的整数。客户端接收到正确数量的整数，但它们在 255 处换行。为什么会这样，正确的方法是什么？

* 服务器 *

import 'dart:async';
import 'dart:io';

main() async 
  final server = await ServerSocket.bind('127.0.0.1', 4041);
  server.listen((Socket socket) 
    print('Got connected $socket.remoteAddress');
    for(int i=0; i<1024; i++) 
      socket.add([i]);
    
    socket.close();
    print('Closed $socket.remoteAddress');
  );

* 客户端 *

import 'dart:async';
import 'dart:io';

main() async 
  final client = await Socket.connect('127.0.0.1', 4041);
  client.listen(
      (var data) => print('Got $data'),
      onDone: ()  print('Done'); client.close(); ,
      onError: (e)  print('Got error $e'); client.close(); );
  print('main done');

另外，感觉 Socket api 有点不同 - 它支持作为流读取的方式比其他语言更 Dartish。但是，如果您只想读取 N 个字节怎么办？你如何做到这一点？我看到了 take 方法（Stream take(int count)），但我不清楚 count 究竟采用了什么方法，尤其是在术语方面读取了多少字节。因为 Socket 实现了 Stream > 并且因为 int 并不是一个真正固定大小的实体（我想？？），你怎么知道已经读取了多少字节？

【参考方案1】：

要明确的一点是，尽管dart:io 中的大多数方法都在List<int> 上运行，但 Dart 中所有 IO 的基本假设是这些列表是字节值列表。文档可能没有那么精确。

这意味着您可以在发送字节时使用您喜欢的任何 List 实现 - 包括类型化数据，例如

var socket = ...
socket.add([1, 2, 3]);
socket.add(new List<int>.generate(3, (int index) => index * index);
socket.add('ASCII'.codeUnits);
socket.add(UTF8.encode('Søren'));

var typedData = new Uint8List(8);
var data = new ByteData.view(typedData.buffer);
data.setInt32(0, 256 * 256 - 1);
data.setInt32(4, 256 * 256 - 1, Endianness.LITTLE_ENDIAN);
socket.add(typedData)

从套接字接收数据时，Socket 流上传递的数据是从操作系统传递的字节块。您无法预测当时接收到的字节数。如果您希望能够读取特定数量的字节，一个选项是实现一个字节读取器，它具有这样的方法：

Future<List<int>> read(int numBytes);

然后可以使用List<int> 流初始化此字节读取器并处理帧。您可以做的是有一个缓冲区（可能使用来自dart:io 的BytesBuilder），它在接收到数据时收集数据。当read 被调用时，Future 在有足够的可用字节时完成。这样的字节读取器还可以在缓冲的数据量达到一定限制时暂停流，并在读取数据时再次恢复。

【参考方案2】：

这对我有用，我不确定这是最优雅的解决方案

import 'dart:io';
import 'dart:async';
import 'dart:typed_data';

main() async 
  final server = await ServerSocket.bind('127.0.0.1', 4041);
  server.listen((Socket socket) 
    print('Got connected $socket.remoteAddress');

    var toByte = new StreamTransformer<List<int>, Uint8List>.fromHandlers(
        handleData: (data, sink) 
      sink.add(new Uint64List.fromList(data).buffer.asUint8List());
    );

    var streamController = new StreamController<List<int>>();
    streamController.stream.transform(toByte).pipe(socket);

    for (int i = 0; i < 1024; i++) 
      streamController.add([i]);
    
    streamController.close();
    print('Closed $socket.remoteAddress');
  );

import 'dart:io';
import 'dart:async';

main() async 
  final Socket client = await Socket.connect('127.0.0.1', 4041);

  var fromByte = new StreamTransformer<List<int>, List<int>>.fromHandlers(
      handleData: (data, sink) 
    sink.add(data.buffer.asInt64List());
  );

  client.transform(fromByte).listen((e) => e.forEach(print));
  print('main done');

最初的尝试：

import 'dart:io';
import 'dart:typed_data';

main() async 
  final server = await ServerSocket.bind('127.0.0.1', 4041);
  server.listen((Socket socket) 
    print('Got connected $socket.remoteAddress');
    for(int i=0; i<1024; i++) 
      socket.add(new Uint64List.fromList([i]).buffer.asUint8List());
    
    socket.close();
    print('Closed $socket.remoteAddress');
  );

import 'dart:io';
import 'dart:typed_data';

main() async 
  final Socket client = await Socket.connect('127.0.0.1', 4041);
  client.listen(
      (var data) 
        var ints = new Uint8List.fromList(data).buffer.asInt64List();
        ints.forEach((i) => print('Got $i'));
      ,
      onDone: ()  print('Done'); client.close(); ,
      onError: (e)  print('Got error $e'); client.close(); );
  print('main done');

如果您不需要 Int64 的范围，您也可以使用 Int32、Int16 或某些 UIntXX 类型或任何最适合您的值范围的类型，以节省一些冗余传输的 0 字节。

我怀疑使用这里解释的转换器https://www.dartlang.org/articles/converters-and-codecs/ 可以用来更优雅地完成它。这似乎与https://gist.github.com/xxgreg/9104926 相似，但我不得不承认我无法将这些示例应用于您的用例。

更新

我让它像上面链接的文章中显示的那样工作

import 'dart:convert';
import 'dart:typed_data';

class IntConverter extends Converter<List<int>, List<int>> 
  const IntConverter();

  List<int> convert(List<int> data) 
    if (data is Uint8List) 
      return data.buffer.asInt64List();
     else 
      return new Uint64List.fromList(data).buffer.asUint8List();
    
  

  IntSink startChunkedConversion(sink) 
    return new IntSink(sink);
  


class IntSink extends ChunkedConversionSink<List<int>> 
  final _converter;
  // fales when this type is used
  // final ChunkedConversionSink<List<int>> _outSink;
  final _outSink;

  IntSink(this._outSink) : _converter = new IntConverter();

  void add(List<int> data) 
    _outSink.add(_converter.convert(data));
  

  void close() 
    _outSink.close();
  

import 'dart:io';
import 'dart:typed_data';

main() async 
  final server = await ServerSocket.bind('127.0.0.1', 4041);
  server.listen((Socket socket) 
    print('Got connected $socket.remoteAddress');

    for (int i = 0; i < 1024; i++) 
      socket.add(new Uint64List.fromList([i]).buffer.asUint8List());
    
    socket.close();
    print('Closed $socket.remoteAddress');
  );

import 'dart:io';
import 'byte_converter.dart';

main() async 
  final Socket client = await Socket.connect('127.0.0.1', 4041);
  client.transform(new IntConverter()).listen((e) => e.forEach(print));
  print('main done');

【讨论】：

谢谢甘特。我想一个基本的后续行动是为什么让套接字实现像 Stream> 这样的东西，因为不清楚发生了什么，因为 int 有一个层次结构。但是 Stream 很明显，它将它留给更高层来解释一些字节数。另外，你如何从套接字中读取 n 个字节？似乎缓冲是固有的，从日志记录中我看到数据中的元素数量是不确定的。

我想应该是Stream<Uint8List> 明确并避免歧义。希望当他看到这个问题时，我们可以从 LRHN 那里得到一些额外的信息。

Uint8List 在 dart:typed_data 中，我猜不想在 dart:io 中引入依赖项。如果 Dart 完全实现了 typedef，那么就可以“typedef byte int;”，然后它就会变成一个 Stream>。我有点喜欢 Streams 和 Lists 的可组合性，所以我不确定我是否喜欢“typedef ByteStream Stream>;”，这将是另一种方式。

@GünterZöchbauer - 假设传递给 IntConverter.convert() 的块总是 8 的倍数是否安全？

数字被转换为二进制并通过网络发送。网络层将二进制文件拆分为任意大小的数据包，然后接收软件从网络层获取数据包，其大小取决于操作系统的网络实现。如果网络决定将数据分割成大小为 1500 字节（不是 8 的倍数）的数据包，会发生什么？您将在一个数据包中获得一半 int64，然后在下一个数据包中获得另一半。您的 IntConverter 类没有正确处理这个问题。